I do not think your changes to JexlOptions are binary compatible so -1 :-( Gary
On Tue, Nov 12, 2019, 17:01 <hen...@apache.org> wrote: > This is an automated email from the ASF dual-hosted git repository. > > henrib pushed a commit to branch master > in repository https://gitbox.apache.org/repos/asf/commons-jexl.git > > > The following commit(s) were added to refs/heads/master by this push: > new 753d6e6 JEXL-307: tidy API (made JexlOptions a concrete non > derivable class), try to ensure lexical interpretation on lexical feature, > allow runtime options to be controlled through pragma (jexl.options) Task > #JEXL-307 - Variable redeclaration option > 753d6e6 is described below > > commit 753d6e634d94022871b481896db78e323d7ccfed > Author: henrib <hen...@apache.org> > AuthorDate: Tue Nov 12 23:00:39 2019 +0100 > > JEXL-307: tidy API (made JexlOptions a concrete non derivable class), > try to ensure lexical interpretation on lexical feature, allow runtime > options to be controlled through pragma (jexl.options) > Task #JEXL-307 - Variable redeclaration option > --- > .../java/org/apache/commons/jexl3/JexlBuilder.java | 21 +- > .../java/org/apache/commons/jexl3/JexlContext.java | 16 ++ > .../java/org/apache/commons/jexl3/JexlEngine.java | 10 +- > .../java/org/apache/commons/jexl3/JexlInfo.java | 11 + > .../java/org/apache/commons/jexl3/JexlOptions.java | 223 +++++++++++++++-- > .../org/apache/commons/jexl3/internal/Engine.java | 68 ++++- > .../apache/commons/jexl3/internal/Interpreter.java | 33 ++- > .../commons/jexl3/internal/InterpreterBase.java | 7 +- > .../org/apache/commons/jexl3/internal/Options.java | 274 > --------------------- > .../org/apache/commons/jexl3/internal/Script.java | 45 +++- > .../jexl3/internal/TemplateInterpreter.java | 2 +- > .../org/apache/commons/jexl3/AntishCallTest.java | 15 +- > .../org/apache/commons/jexl3/Issues300Test.java | 25 +- > .../java/org/apache/commons/jexl3/JXLTTest.java | 3 +- > .../org/apache/commons/jexl3/JexlEvalContext.java | 3 +- > .../org/apache/commons/jexl3/JexlTestCase.java | 2 +- > .../java/org/apache/commons/jexl3/LexicalTest.java | 43 ++++ > 17 files changed, 431 insertions(+), 370 deletions(-) > > diff --git a/src/main/java/org/apache/commons/jexl3/JexlBuilder.java > b/src/main/java/org/apache/commons/jexl3/JexlBuilder.java > index 35c8d5f..744dfe1 100644 > --- a/src/main/java/org/apache/commons/jexl3/JexlBuilder.java > +++ b/src/main/java/org/apache/commons/jexl3/JexlBuilder.java > @@ -18,7 +18,6 @@ > package org.apache.commons.jexl3; > > import org.apache.commons.jexl3.internal.Engine; > -import org.apache.commons.jexl3.internal.Options; > import org.apache.commons.jexl3.introspection.JexlSandbox; > import org.apache.commons.jexl3.introspection.JexlUberspect; > import org.apache.commons.logging.Log; > @@ -81,7 +80,7 @@ public class JexlBuilder { > private Boolean cancellable = null; > > /** The options. */ > - private final Options options = new Options(); > + private final JexlOptions options = new JexlOptions(); > > /** Whether getVariables considers all potential equivalent syntactic > forms. */ > private Boolean collectAll = null; > @@ -109,23 +108,7 @@ public class JexlBuilder { > > /** The features. */ > private JexlFeatures features = null; > - > - /** > - * Sets the default (static, shared) option flags. > - * <p> > - * Whenever possible, we recommend using JexlBuilder methods to > unambiguously instantiate a JEXL > - * engine; this method should only be used for testing / validation. > - * <p>A '+flag' or 'flag' will set the option named 'flag' as true, > '-flag' set as false. > - * The possible flag names are: > - * cancellable, strict, silent, safe, lexical, antish, lexicalShade > - * <p>Calling JexlBuilder.setDefaultOptions("+safe") once before JEXL > engine creation > - * may ease validating JEXL3.2 in your environment. > - * @param flags the flags to set > - */ > - public static void setDefaultOptions(String...flags) { > - Options.setDefaultFlags(flags); > - } > - > + > /** > * Sets the JexlUberspect instance the engine will use. > * > diff --git a/src/main/java/org/apache/commons/jexl3/JexlContext.java > b/src/main/java/org/apache/commons/jexl3/JexlContext.java > index fdc85a3..ce730f7 100644 > --- a/src/main/java/org/apache/commons/jexl3/JexlContext.java > +++ b/src/main/java/org/apache/commons/jexl3/JexlContext.java > @@ -159,4 +159,20 @@ public interface JexlContext { > */ > JexlOptions getEngineOptions(); > } > + > + /** > + * A marker interface of the JexlContext that processes pragmas. > + * It is called by the engine before interpreter creation; as a > marker of > + * JexlContext, it is expected to have access and interact with the > context > + * instance. > + * @since 3.2 > + */ > + interface PragmaProcessor { > + /** > + * Process one pragma. > + * @param key the key > + * @param value the value > + */ > + void processPragma(String key, Object value); > + } > } > diff --git a/src/main/java/org/apache/commons/jexl3/JexlEngine.java > b/src/main/java/org/apache/commons/jexl3/JexlEngine.java > index bc41a82..7b9d198 100644 > --- a/src/main/java/org/apache/commons/jexl3/JexlEngine.java > +++ b/src/main/java/org/apache/commons/jexl3/JexlEngine.java > @@ -352,7 +352,7 @@ public abstract class JexlEngine { > * @return A {@link JexlScript} which can be executed using a {@link > JexlContext} > * @throws JexlException if there is a problem parsing the script > */ > - public abstract JexlScript createScript(JexlFeatures features, > JexlInfo info, String source, String[] names); > + public abstract JexlScript createScript(JexlFeatures features, > JexlInfo info, String source, String... names); > > /** > * Creates a JexlScript from a String containing valid JEXL syntax. > @@ -365,7 +365,7 @@ public abstract class JexlEngine { > * @return A {@link JexlScript} which can be executed using a {@link > JexlContext} > * @throws JexlException if there is a problem parsing the script > */ > - public final JexlScript createScript(JexlInfo info, String source, > String[] names) { > + public final JexlScript createScript(JexlInfo info, String source, > String... names) { > return createScript(null, info, source, names); > } > > @@ -378,7 +378,7 @@ public abstract class JexlEngine { > * @throws JexlException if there is a problem parsing the script. > */ > public final JexlScript createScript(String scriptText) { > - return createScript(null, null, scriptText, null); > + return createScript(null, null, scriptText, (String[]) null); > } > > /** > @@ -404,7 +404,7 @@ public abstract class JexlEngine { > * @throws JexlException if there is a problem reading or parsing the > script. > */ > public final JexlScript createScript(File scriptFile) { > - return createScript(null, null, readSource(scriptFile), null); > + return createScript(null, null, readSource(scriptFile), > (String[]) null); > } > > /** > @@ -445,7 +445,7 @@ public abstract class JexlEngine { > * @throws JexlException if there is a problem reading or parsing the > script. > */ > public final JexlScript createScript(URL scriptUrl) { > - return createScript(null, readSource(scriptUrl), null); > + return createScript(null, readSource(scriptUrl), (String[]) null); > } > > /** > diff --git a/src/main/java/org/apache/commons/jexl3/JexlInfo.java > b/src/main/java/org/apache/commons/jexl3/JexlInfo.java > index 19a4a72..296138b 100644 > --- a/src/main/java/org/apache/commons/jexl3/JexlInfo.java > +++ b/src/main/java/org/apache/commons/jexl3/JexlInfo.java > @@ -17,6 +17,8 @@ > > package org.apache.commons.jexl3; > > +import org.apache.commons.jexl3.internal.Script; > + > /** > * Helper class to carry information such as a url/file name, line and > column for > * debugging information reporting. > @@ -182,5 +184,14 @@ public class JexlInfo { > public final int getColumn() { > return column; > } > + > + /** > + * Gets the info from a script. > + * @param script the script > + * @return the info > + */ > + public static JexlInfo from(JexlScript script) { > + return script instanceof Script? ((Script) script).getInfo() : > null; > + } > } > > diff --git a/src/main/java/org/apache/commons/jexl3/JexlOptions.java > b/src/main/java/org/apache/commons/jexl3/JexlOptions.java > index dc35074..c650e9b 100644 > --- a/src/main/java/org/apache/commons/jexl3/JexlOptions.java > +++ b/src/main/java/org/apache/commons/jexl3/JexlOptions.java > @@ -18,6 +18,7 @@ > package org.apache.commons.jexl3; > > import java.math.MathContext; > +import org.apache.commons.jexl3.internal.Engine; > > /** > * Flags and properties that can alter the evaluation behavior. > @@ -35,31 +36,150 @@ import java.math.MathContext; > * <p>This interface replaces the now deprecated JexlEngine.Options. > * @since 3.2 > */ > -public interface JexlOptions { > +public final class JexlOptions { > + /** The local shade bit. */ > + private static final int SHADE = 6; > + /** The antish var bit. */ > + private static final int ANTISH = 5; > + /** The lexical scope bit. */ > + private static final int LEXICAL = 4; > + /** The safe bit. */ > + private static final int SAFE = 3; > + /** The silent bit. */ > + private static final int SILENT = 2; > + /** The strict bit. */ > + private static final int STRICT = 1; > + /** The cancellable bit. */ > + private static final int CANCELLABLE = 0; > + /** The flags names ordered. */ > + private static final String[] NAMES = { > + "cancellable", "strict", "silent", "safe", "lexical", "antish", > "lexicalShade" > + }; > + /** Default mask .*/ > + private static int DEFAULT = 1 /*<< CANCELLABLE*/ | 1 << STRICT | 1 > << ANTISH | 1 << SAFE; > + /** The arithmetic math context. */ > + private MathContext mathContext = null; > + /** The arithmetic math scale. */ > + private int mathScale = Integer.MIN_VALUE; > + /** The arithmetic strict math flag. */ > + private boolean strictArithmetic = true; > + /** The default flags, all but safe. */ > + private int flags = DEFAULT; > + > + /** > + * Sets the value of a flag in a mask. > + * @param ordinal the flag ordinal > + * @param mask the flags mask > + * @param value true or false > + * @return the new flags mask value > + */ > + private static int set(int ordinal, int mask, boolean value) { > + return value? mask | (1 << ordinal) : mask & ~(1 << ordinal); > + } > + > + /** > + * Checks the value of a flag in the mask. > + * @param ordinal the flag ordinal > + * @param mask the flags mask > + * @return the mask value with this flag or-ed in > + */ > + private static boolean isSet(int ordinal, int mask) { > + return (mask & 1 << ordinal) != 0; > + } > + > + /** > + * Default ctor. > + */ > + public JexlOptions() {} > + > + /** > + * Sets the default (static, shared) option flags. > + * <p> > + * Whenever possible, we recommend using JexlBuilder methods to > unambiguously instantiate a JEXL > + * engine; this method should only be used for testing / validation. > + * <p>A '+flag' or 'flag' will set the option named 'flag' as true, > '-flag' set as false. > + * The possible flag names are: > + * cancellable, strict, silent, safe, lexical, antish, lexicalShade > + * <p>Calling JexlBuilder.setDefaultOptions("+safe") once before JEXL > engine creation > + * may ease validating JEXL3.2 in your environment. > + * @param flags the flags to set > + */ > + public static void setDefaultFlags(String...flags) { > + DEFAULT = parseFlags(DEFAULT, flags); > + } > + > + /** > + * Parses flags by name. > + * <p>A '+flag' or 'flag' will set flag as true, '-flag' set as false. > + * The possible flag names are: > + * cancellable, strict, silent, safe, lexical, antish, lexicalShade > + * @param mask the initial mask state > + * @param flags the flags to set > + * @return the flag mask updated > + */ > + public static int parseFlags(int mask, String...flags) { > + for(String name : flags) { > + boolean b = true; > + if (name.charAt(0) == '+') { > + name = name.substring(1); > + } else if (name.charAt(0) == '-') { > + name = name.substring(1); > + b = false; > + } > + for(int flag = 0; flag < NAMES.length; ++flag) { > + if (NAMES[flag].equals(name)) { > + if (b) { > + mask |= (1 << flag); > + } else { > + mask &= ~(1 << flag); > + } > + break; > + } > + } > + } > + return mask; > + } > + > + /** > + * Sets this option flags using the +/- syntax. > + * @param opts the option flags > + */ > + public void setFlags(String[] opts) { > + flags = parseFlags(flags, opts); > + } > + > /** > * The MathContext instance used for +,-,/,*,% operations on big > decimals. > * @return the math context > */ > - MathContext getMathContext(); > + public MathContext getMathContext() { > + return mathContext; > + } > > /** > * The BigDecimal scale used for comparison and coercion operations. > * @return the scale > */ > - int getMathScale(); > + public int getMathScale() { > + return mathScale; > + } > > /** > * Checks whether evaluation will attempt resolving antish variable > names. > * @return true if antish variables are solved, false otherwise > */ > - boolean isAntish(); > + public boolean isAntish() { > + return isSet(ANTISH, flags); > + } > > /** > * Checks whether evaluation will throw JexlException.Cancel (true) or > * return null (false) if interrupted. > * @return true when cancellable, false otherwise > */ > - boolean isCancellable(); > + public boolean isCancellable() { > + return isSet(CANCELLABLE, flags); > + } > > /** > * Checks whether runtime variable scope is lexical. > @@ -67,7 +187,9 @@ public interface JexlOptions { > * Redefining a variable in the same lexical unit will generate > errors. > * @return true if scope is lexical, false otherwise > */ > - boolean isLexical(); > + public boolean isLexical() { > + return isSet(LEXICAL, flags); > + } > > /** > * Checks whether local variables shade global ones. > @@ -79,122 +201,169 @@ public interface JexlOptions { > * raise an error. > * @return true if lexical shading is applied, false otherwise > */ > - boolean isLexicalShade(); > + public boolean isLexicalShade() { > + return isSet(SHADE, flags); > + } > > /** > * Checks whether the engine considers null in navigation expression > as > * errors during evaluation.. > * @return true if safe, false otherwise > */ > - boolean isSafe(); > + public boolean isSafe() { > + return isSet(SAFE, flags); > + } > > /** > * Checks whether the engine will throw a {@link JexlException} when > an > * error is encountered during evaluation. > * @return true if silent, false otherwise > */ > - boolean isSilent(); > + public boolean isSilent() { > + return isSet(SILENT, flags); > + } > > /** > * Checks whether the engine considers unknown variables, methods and > * constructors as errors during evaluation. > * @return true if strict, false otherwise > */ > - boolean isStrict(); > + public boolean isStrict() { > + return isSet(STRICT, flags); > + } > > /** > * Checks whether the arithmetic triggers errors during evaluation > when null > * is used as an operand. > * @return true if strict, false otherwise > */ > - boolean isStrictArithmetic(); > + public boolean isStrictArithmetic() { > + return strictArithmetic; > + } > > /** > * Sets whether the engine will attempt solving antish variable names > from > * context. > * @param flag true if antish variables are solved, false otherwise > */ > - void setAntish(boolean flag); > + public void setAntish(boolean flag) { > + flags = set(ANTISH, flags, flag); > + } > > /** > * Sets whether the engine will throw JexlException.Cancel (true) or > return > * null (false) when interrupted during evaluation. > * @param flag true when cancellable, false otherwise > */ > - void setCancellable(boolean flag); > + public void setCancellable(boolean flag) { > + flags = set(CANCELLABLE, flags, flag); > + } > > /** > * Sets whether the engine uses a strict block lexical scope during > * evaluation. > * @param flag true if lexical scope is used, false otherwise > */ > - void setLexical(boolean flag); > + public void setLexical(boolean flag) { > + flags = set(LEXICAL, flags, flag); > + } > > /** > * Sets whether the engine strictly shades global variables. > * Local symbols shade globals after definition and creating global > * variables is prohibited evaluation. > + * If setting to lexical shade, lexical is also set. > * @param flag true if creation is allowed, false otherwise > */ > - void setLexicalShade(boolean flag); > + public void setLexicalShade(boolean flag) { > + flags = set(SHADE, flags, flag); > + if (flag) { > + flags = set(LEXICAL, flags, true); > + } > + } > > /** > * Sets the arithmetic math context. > * @param mcontext the context > */ > - void setMathContext(MathContext mcontext); > + public void setMathContext(MathContext mcontext) { > + this.mathContext = mcontext; > + } > > /** > * Sets the arithmetic math scale. > * @param mscale the scale > */ > - void setMathScale(int mscale); > + public void setMathScale(int mscale) { > + this.mathScale = mscale; > + } > > /** > * Sets whether the engine considers null in navigation expression as > errors > * during evaluation. > * @param flag true if safe, false otherwise > */ > - void setSafe(boolean flag); > + public void setSafe(boolean flag) { > + flags = set(SAFE, flags, flag); > + } > > /** > * Sets whether the engine will throw a {@link JexlException} when an > error > * is encountered during evaluation. > * @param flag true if silent, false otherwise > */ > - void setSilent(boolean flag); > + public void setSilent(boolean flag) { > + flags = set(SILENT, flags, flag); > + } > > /** > * Sets whether the engine considers unknown variables, methods and > * constructors as errors during evaluation. > * @param flag true if strict, false otherwise > */ > - void setStrict(boolean flag); > + public void setStrict(boolean flag) { > + flags = set(STRICT, flags, flag); > + } > > /** > * Sets the strict arithmetic flag. > * @param stricta true or false > */ > - void setStrictArithmetic(boolean stricta); > + public void setStrictArithmetic(boolean stricta) { > + this.strictArithmetic = stricta; > + } > > /** > * Set options from engine. > * @param jexl the engine > * @return this instance > - */ > - JexlOptions set(JexlEngine jexl); > + */ > + public JexlOptions set(JexlEngine jexl) { > + if (jexl instanceof Engine) { > + ((Engine) jexl).optionsSet(this); > + } > + return this; > + } > > /** > * Set options from options. > - * @param options the options > + * @param src the options > * @return this instance > */ > - JexlOptions set(JexlOptions options); > - > + public JexlOptions set(JexlOptions src) { > + mathContext = src.mathContext; > + mathScale = src.mathScale; > + strictArithmetic = src.strictArithmetic; > + flags = src.flags; > + return this; > + } > + > /** > * Creates a copy of this instance. > * @return a copy > */ > - JexlOptions copy(); > + public JexlOptions copy() { > + return new JexlOptions().set(this); > + } > > } > \ No newline at end of file > diff --git a/src/main/java/org/apache/commons/jexl3/internal/Engine.java > b/src/main/java/org/apache/commons/jexl3/internal/Engine.java > index d752cca..4895578 100644 > --- a/src/main/java/org/apache/commons/jexl3/internal/Engine.java > +++ b/src/main/java/org/apache/commons/jexl3/internal/Engine.java > @@ -74,6 +74,10 @@ public class Engine extends JexlEngine { > private UberspectHolder() {} > } > /** > + * The name of the options pragma. > + */ > + protected static final String PRAGMA_OPTIONS = "jexl.options"; > + /** > * The Log to which all JexlEngine messages will be logged. > */ > protected final Log logger; > @@ -347,18 +351,62 @@ public class Engine extends JexlEngine { > cache.clear(); > } > } > - > + > + /** > + * Sets options from this engine options. > + * @param opts the options to set > + * @return the options > + */ > + public JexlOptions optionsSet(JexlOptions opts) { > + if (opts != null) { > + opts.set(options); > + } > + return opts; > + } > + > + /** > + * Creates a script evaluation options. > + * <p>This also calls the pragma processor if any > + * @param script the script > + * @param context the context > + * @return the options > + */ > + protected JexlOptions createOptions(Script script, JexlContext > context) { > + JexlOptions opts = options(context); > + Map<String, Object> pragmas = script.getPragmas(); > + if (pragmas != null) { > + JexlContext.PragmaProcessor processor = > + context instanceof JexlContext.PragmaProcessor > + ? (JexlContext.PragmaProcessor) context > + : null; > + for(Map.Entry<String, Object> pragma : pragmas.entrySet()) { > + String key = pragma.getKey(); > + Object value = pragma.getValue(); > + if (PRAGMA_OPTIONS.equals(key) && opts != null) { > + if (value instanceof String) { > + String[] vs = ((String) value).split(" "); > + opts.setFlags(vs); > + } > + } > + if (processor != null) { > + processor.processPragma(key, value); > + } > + } > + } > + return opts; > + } > + > /** > * Creates an interpreter. > * @param context a JexlContext; if null, the empty context is used > instead. > * @param frame the interpreter frame > + * @param opts the evaluation options > * @return an Interpreter > */ > - protected Interpreter createInterpreter(JexlContext context, Frame > frame) { > - return new Interpreter(this, context, frame); > + protected Interpreter createInterpreter(JexlContext context, Frame > frame, JexlOptions opts) { > + return new Interpreter(this, opts, context, frame); > } > > - > @Override > public Script createExpression(JexlInfo info, String expression) { > return createScript(expressionFeatures, info, expression, null); > @@ -371,8 +419,12 @@ public class Engine extends JexlEngine { > } > String source = trimSource(scriptText); > Scope scope = names == null ? null : new Scope(null, names); > - ASTJexlScript tree = parse(info, features == null? scriptFeatures > : features, source, scope); > - return new Script(this, source, tree); > + JexlFeatures ftrs = features == null? scriptFeatures : features; > + ASTJexlScript tree = parse(info, ftrs, source, scope); > + // when parsing lexical, try hard to run lexical > + return ftrs.isLexical() > + ? new Script.Lexical(this, source, tree) > + : new Script(this, source, tree); > } > > /** > @@ -405,7 +457,7 @@ public class Engine extends JexlEngine { > final ASTJexlScript script = parse(null, PROPERTY_FEATURES, > src, scope); > final JexlNode node = script.jjtGetChild(0); > final Frame frame = script.createFrame(bean); > - final Interpreter interpreter = createInterpreter(context, > frame); > + final Interpreter interpreter = createInterpreter(context, > frame, null); > return interpreter.visitLexicalNode(node, null); > } catch (JexlException xjexl) { > if (silent) { > @@ -434,7 +486,7 @@ public class Engine extends JexlEngine { > final ASTJexlScript script = parse(null, PROPERTY_FEATURES, > src, scope); > final JexlNode node = script.jjtGetChild(0); > final Frame frame = script.createFrame(bean, value); > - final Interpreter interpreter = createInterpreter(context, > frame); > + final Interpreter interpreter = createInterpreter(context, > frame, null); > interpreter.visitLexicalNode(node, null); > } catch (JexlException xjexl) { > if (silent) { > diff --git > a/src/main/java/org/apache/commons/jexl3/internal/Interpreter.java > b/src/main/java/org/apache/commons/jexl3/internal/Interpreter.java > index ed7efa7..9c27f61 100644 > --- a/src/main/java/org/apache/commons/jexl3/internal/Interpreter.java > +++ b/src/main/java/org/apache/commons/jexl3/internal/Interpreter.java > @@ -17,13 +17,18 @@ > //CSOFF: FileLength > package org.apache.commons.jexl3.internal; > > +import java.util.Iterator; > +import java.util.concurrent.Callable; > + > import org.apache.commons.jexl3.JexlArithmetic; > import org.apache.commons.jexl3.JexlContext; > import org.apache.commons.jexl3.JexlEngine; > import org.apache.commons.jexl3.JexlException; > import org.apache.commons.jexl3.JexlOperator; > +import org.apache.commons.jexl3.JexlOptions; > import org.apache.commons.jexl3.JexlScript; > import org.apache.commons.jexl3.JxltEngine; > + > import org.apache.commons.jexl3.introspection.JexlMethod; > import org.apache.commons.jexl3.introspection.JexlPropertyGet; > > @@ -105,9 +110,6 @@ import > org.apache.commons.jexl3.parser.ASTWhileStatement; > import org.apache.commons.jexl3.parser.JexlNode; > import org.apache.commons.jexl3.parser.Node; > > -import java.util.Iterator; > -import java.util.concurrent.Callable; > - > /** > * An interpreter of JEXL syntax. > * > @@ -130,11 +132,12 @@ public class Interpreter extends InterpreterBase { > /** > * Creates an interpreter. > * @param engine the engine creating this interpreter > - * @param aContext the context to evaluate expression > - * @param eFrame the interpreter evaluation frame > + * @param aContext the evaluation context, global variables, methods > and functions > + * @param opts the evaluation options, flags modifying evaluation > behavior > + * @param eFrame the evaluation frame, arguments and local variables > */ > - protected Interpreter(Engine engine, JexlContext aContext, Frame > eFrame) { > - super(engine, aContext); > + protected Interpreter(Engine engine, JexlOptions opts, JexlContext > aContext, Frame eFrame) { > + super(engine, opts, aContext); > this.frame = eFrame; > } > > @@ -1122,7 +1125,7 @@ public class Interpreter extends InterpreterBase { > JexlNode objectNode = null; > JexlNode ptyNode = null; > StringBuilder ant = null; > - boolean antish = !(parent instanceof ASTReference) && > options.isAntish(); > + boolean antish = !(parent instanceof ASTReference); > int v = 1; > main: > for (int c = 0; c < numChildren; c++) { > @@ -1172,15 +1175,21 @@ public class Interpreter extends InterpreterBase { > if (first instanceof ASTIdentifier) { > ASTIdentifier afirst = (ASTIdentifier) first; > ant = new StringBuilder(afirst.getName()); > - // skip the first node case since it was trialed > in jjtAccept above and returned null > - if (c == 0) { > - continue; > - } > + // skip the else...* > } else { > // not an identifier, not antish > ptyNode = objectNode; > break main; > } > + // *... and continue > + if (!options.isAntish()) { > + antish = false; > + continue; > + } > + // skip the first node case since it was trialed in > jjtAccept above and returned null > + if (c == 0) { > + continue; > + } > } > // catch up to current node > for (; v <= c; ++v) { > diff --git > a/src/main/java/org/apache/commons/jexl3/internal/InterpreterBase.java > b/src/main/java/org/apache/commons/jexl3/internal/InterpreterBase.java > index 74c8f8f..504c1c1 100644 > --- a/src/main/java/org/apache/commons/jexl3/internal/InterpreterBase.java > +++ b/src/main/java/org/apache/commons/jexl3/internal/InterpreterBase.java > @@ -78,16 +78,17 @@ public abstract class InterpreterBase extends > ParserVisitor { > /** > * Creates an interpreter base. > * @param engine the engine creating this interpreter > - * @param aContext the context to evaluate expression > + * @param opts the evaluation options > + * @param aContext the evaluation context > */ > - protected InterpreterBase(Engine engine, JexlContext aContext) { > + protected InterpreterBase(Engine engine, JexlOptions opts, > JexlContext aContext) { > this.jexl = engine; > this.logger = jexl.logger; > this.uberspect = jexl.uberspect; > this.context = aContext != null ? aContext : Engine.EMPTY_CONTEXT; > this.cache = engine.cache != null; > JexlArithmetic jexla = jexl.arithmetic; > - this.options = jexl.options(context); > + this.options = opts == null? engine.options(aContext) : opts; > this.arithmetic = jexla.options(options); > if (arithmetic != jexla && > !arithmetic.getClass().equals(jexla.getClass())) { > logger.warn("expected arithmetic to be " + > jexla.getClass().getSimpleName() > diff --git a/src/main/java/org/apache/commons/jexl3/internal/Options.java > b/src/main/java/org/apache/commons/jexl3/internal/Options.java > deleted file mode 100644 > index 04dd182..0000000 > --- a/src/main/java/org/apache/commons/jexl3/internal/Options.java > +++ /dev/null > @@ -1,274 +0,0 @@ > -/* > - * Licensed to the Apache Software Foundation (ASF) under one or more > - * contributor license agreements. See the NOTICE file distributed with > - * this work for additional information regarding copyright ownership. > - * The ASF licenses this file to You under the Apache License, Version 2.0 > - * (the "License"); you may not use this file except in compliance with > - * the License. You may obtain a copy of the License at > - * > - * http://www.apache.org/licenses/LICENSE-2.0 > - * > - * Unless required by applicable law or agreed to in writing, software > - * distributed under the License is distributed on an "AS IS" BASIS, > - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or > implied. > - * See the License for the specific language governing permissions and > - * limitations under the License. > - */ > - > -package org.apache.commons.jexl3.internal; > - > -import org.apache.commons.jexl3.JexlOptions; > -import org.apache.commons.jexl3.JexlEngine; > - > -import java.math.MathContext; > - > -/** > - * A basic implementation of JexlOptions. > - * <p>Thread safety is only guaranteed if no modifications (call set* > method) > - * occurs in different threads; note however that using the 'callable()' > method to > - * allow a script to run as such will use a copy. > - */ > -public class Options implements JexlOptions { > - /** The local shade bit. */ > - protected static final int SHADE = 6; > - /** The antish var bit. */ > - protected static final int ANTISH = 5; > - /** The lexical scope bit. */ > - protected static final int LEXICAL = 4; > - /** The safe bit. */ > - protected static final int SAFE = 3; > - /** The silent bit. */ > - protected static final int SILENT = 2; > - /** The strict bit. */ > - protected static final int STRICT = 1; > - /** The cancellable bit. */ > - protected static final int CANCELLABLE = 0; > - /** The flags names ordered. */ > - private static final String[] NAMES = { > - "cancellable", "strict", "silent", "safe", "lexical", "antish", > "lexicalShade" > - }; > - /** Default mask .*/ > - protected static int DEFAULT = 1 /*<< CANCELLABLE*/ | 1 << STRICT | 1 > << ANTISH | 1 << SAFE; > - /** The arithmetic math context. */ > - private MathContext mathContext = null; > - /** The arithmetic math scale. */ > - private int mathScale = Integer.MIN_VALUE; > - /** The arithmetic strict math flag. */ > - private boolean strictArithmetic = true; > - /** The default flags, all but safe. */ > - private int flags = DEFAULT; > - > - /** > - * Sets the value of a flag in a mask. > - * @param ordinal the flag ordinal > - * @param mask the flags mask > - * @param value true or false > - * @return the new flags mask value > - */ > - protected static int set(int ordinal, int mask, boolean value) { > - return value? mask | (1 << ordinal) : mask & ~(1 << ordinal); > - } > - > - /** > - * Checks the value of a flag in the mask. > - * @param ordinal the flag ordinal > - * @param mask the flags mask > - * @return the mask value with this flag or-ed in > - */ > - protected static boolean isSet(int ordinal, int mask) { > - return (mask & 1 << ordinal) != 0; > - } > - > - /** > - * Default ctor. > - */ > - public Options() {} > - > - /** > - * Sets the default flags. > - * <p>Used by tests to force default options. > - * @param flags the flags to set > - */ > - public static void setDefaultFlags(String...flags) { > - DEFAULT = parseFlags(DEFAULT, flags); > - } > - > - /** > - * Parses flags by name. > - * <p>A '+flag' or 'flag' will set flag as true, '-flag' set as false. > - * The possible flag names are: > - * cancellable, strict, silent, safe, lexical, antish, lexicalShade > - * @param mask the initial mask state > - * @param flags the flags to set > - * @return the flag mask updated > - */ > - public static int parseFlags(int mask, String...flags) { > - for(String name : flags) { > - boolean b = true; > - if (name.charAt(0) == '+') { > - name = name.substring(1); > - } else if (name.charAt(0) == '-') { > - name = name.substring(1); > - b = false; > - } > - for(int flag = 0; flag < NAMES.length; ++flag) { > - if (NAMES[flag].equals(name)) { > - if (b) { > - mask |= (1 << flag); > - } else { > - mask &= ~(1 << flag); > - } > - break; > - } > - } > - } > - return mask; > - } > - > - @Override > - public Options set(JexlEngine jexl) { > - if (jexl instanceof Engine) { > - set(((Engine) jexl).options); > - } else { > - mathContext = jexl.getArithmetic().getMathContext(); > - mathScale = jexl.getArithmetic().getMathScale(); > - strictArithmetic = jexl.getArithmetic().isStrict(); > - set(STRICT, flags, jexl.isStrict()); > - set(SILENT, flags, jexl.isSilent()); > - set(SAFE, flags, jexl.isSafe()); > - set(CANCELLABLE, flags, jexl.isCancellable()); > - } > - return this; > - } > - > - @Override > - public Options set(JexlOptions opts) { > - if (opts instanceof Options) { > - Options src = (Options) opts; > - mathContext = src.mathContext; > - mathScale = src.mathScale; > - strictArithmetic = src.strictArithmetic; > - flags = src.flags; > - } else { > - mathContext = opts.getMathContext(); > - mathScale = opts.getMathScale(); > - strictArithmetic = opts.isStrict(); > - int mask = DEFAULT; > - mask = set(STRICT, mask, opts.isStrict()); > - mask = set(SILENT, mask, opts.isSilent()); > - mask = set(SAFE, mask, opts.isSafe()); > - mask = set(CANCELLABLE, mask, opts.isCancellable()); > - mask = set(LEXICAL, mask, opts.isLexical()); > - mask = set(SHADE, mask, opts.isLexicalShade()); > - mask = set(ANTISH, mask, opts.isAntish()); > - flags = mask; > - } > - return this; > - } > - > - @Override > - public Options copy() { > - return new Options().set(this); > - } > - > - @Override > - public void setAntish(boolean flag) { > - flags = set(ANTISH, flags, flag); > - } > - > - @Override > - public void setMathContext(MathContext mcontext) { > - this.mathContext = mcontext; > - } > - > - @Override > - public void setMathScale(int mscale) { > - this.mathScale = mscale; > - } > - > - @Override > - public void setStrictArithmetic(boolean stricta) { > - this.strictArithmetic = stricta; > - } > - > - @Override > - public void setStrict(boolean flag) { > - flags = set(STRICT, flags, flag); > - } > - > - @Override > - public void setSafe(boolean flag) { > - flags = set(SAFE, flags, flag); > - } > - > - @Override > - public void setSilent(boolean flag) { > - flags = set(SILENT, flags, flag); > - } > - > - @Override > - public void setCancellable(boolean flag) { > - flags = set(CANCELLABLE, flags, flag); > - } > - > - @Override > - public void setLexical(boolean flag) { > - flags = set(LEXICAL, flags, flag); > - } > - > - @Override > - public void setLexicalShade(boolean flag) { > - flags = set(SHADE, flags, flag); > - } > - > - @Override > - public boolean isAntish() { > - return isSet(ANTISH, flags); > - } > - > - @Override > - public boolean isSilent() { > - return isSet(SILENT, flags); > - } > - > - @Override > - public boolean isStrict() { > - return isSet(STRICT, flags); > - } > - > - @Override > - public boolean isSafe() { > - return isSet(SAFE, flags); > - } > - > - @Override > - public boolean isCancellable() { > - return isSet(CANCELLABLE, flags); > - } > - > - @Override > - public boolean isLexical() { > - return isSet(LEXICAL, flags); > - } > - > - @Override > - public boolean isLexicalShade() { > - return isSet(SHADE, flags); > - } > - > - @Override > - public boolean isStrictArithmetic() { > - return strictArithmetic; > - } > - > - @Override > - public MathContext getMathContext() { > - return mathContext; > - } > - > - @Override > - public int getMathScale() { > - return mathScale; > - } > - > -} > diff --git a/src/main/java/org/apache/commons/jexl3/internal/Script.java > b/src/main/java/org/apache/commons/jexl3/internal/Script.java > index 62ecaca..593ad08 100644 > --- a/src/main/java/org/apache/commons/jexl3/internal/Script.java > +++ b/src/main/java/org/apache/commons/jexl3/internal/Script.java > @@ -17,6 +17,8 @@ > package org.apache.commons.jexl3.internal; > > import org.apache.commons.jexl3.JexlContext; > +import org.apache.commons.jexl3.JexlInfo; > +import org.apache.commons.jexl3.JexlOptions; > import org.apache.commons.jexl3.JexlEngine; > import org.apache.commons.jexl3.JexlScript; > import org.apache.commons.jexl3.JexlExpression; > @@ -96,7 +98,39 @@ public class Script implements JexlScript, > JexlExpression { > protected Frame createFrame(Object[] args) { > return script.createFrame(args); > } > + > + /** > + * Creates this script options for evaluation. > + * <p>This also calls the pragma processor > + * @param context the context > + * @return the options > + */ > + protected JexlOptions createOptions(JexlContext context) { > + return jexl.createOptions(this, context); > + } > + > + /** > + * A lexical script, ensures options are lexical. > + */ > + public static class Lexical extends Script { > + /** > + * Sole ctor. > + * @param engine the engine > + * @param expr the source. > + * @param ref the ast > + */ > + protected Lexical(Engine engine, String expr, ASTJexlScript ref) { > + super(engine, expr, ref); > + } > > + @Override > + public JexlOptions createOptions(JexlContext ctxt) { > + JexlOptions opts = super.createOptions(ctxt); > + opts.setLexical(true); > + return opts; > + } > + } > + > /** > * Creates this script interpreter. > * @param context the context > @@ -104,7 +138,7 @@ public class Script implements JexlScript, > JexlExpression { > * @return the interpreter > */ > protected Interpreter createInterpreter(JexlContext context, Frame > frame) { > - return jexl.createInterpreter(context, frame); > + return jexl.createInterpreter(context, frame, > createOptions(context)); > } > > /** > @@ -215,6 +249,13 @@ public class Script implements JexlScript, > JexlExpression { > public String[] getLocalVariables() { > return script.getLocalVariables(); > } > + > + /** > + * @return the info > + */ > + public JexlInfo getInfo() { > + return script.jexlInfo(); > + } > > /** > * Gets this script variables. > @@ -259,7 +300,7 @@ public class Script implements JexlScript, > JexlExpression { > */ > @Override > public Callable callable(JexlContext context, Object... args) { > - return new Callable(jexl.createInterpreter(context, > script.createFrame(args))); > + return new Callable(createInterpreter(context, > script.createFrame(args))); > } > > /** > diff --git > a/src/main/java/org/apache/commons/jexl3/internal/TemplateInterpreter.java > b/src/main/java/org/apache/commons/jexl3/internal/TemplateInterpreter.java > index 17b0ff9..7babe6f 100644 > --- > a/src/main/java/org/apache/commons/jexl3/internal/TemplateInterpreter.java > +++ > b/src/main/java/org/apache/commons/jexl3/internal/TemplateInterpreter.java > @@ -48,7 +48,7 @@ public class TemplateInterpreter extends Interpreter { > */ > TemplateInterpreter(Engine jexl, > JexlContext jcontext, Frame jframe, TemplateExpression[] > expressions, Writer out) { > - super(jexl, jcontext, jframe); > + super(jexl, null, jcontext, jframe); > exprs = expressions; > writer = out; > block = new LexicalFrame(frame, null); > diff --git a/src/test/java/org/apache/commons/jexl3/AntishCallTest.java > b/src/test/java/org/apache/commons/jexl3/AntishCallTest.java > index 5f23b11..8397ce0 100644 > --- a/src/test/java/org/apache/commons/jexl3/AntishCallTest.java > +++ b/src/test/java/org/apache/commons/jexl3/AntishCallTest.java > @@ -173,7 +173,8 @@ public class AntishCallTest extends JexlTestCase { > // JEXL-300 > @Test > public void testSafeAnt() throws Exception { > - JexlContext ctxt = new MapContext(); > + JexlEvalContext ctxt = new JexlEvalContext(); > + JexlOptions options = ctxt.getEngineOptions(); > ctxt.set("x.y.z", 42); > JexlScript script; > Object result; > @@ -182,6 +183,18 @@ public class AntishCallTest extends JexlTestCase { > result = script.execute(ctxt); > Assert.assertEquals(42, result); > Assert.assertEquals(42, ctxt.get("x.y.z")); > + > + options.setAntish(false); > + try { > + result = script.execute(ctxt); > + Assert.fail("antish var shall not be resolved"); > + } catch(JexlException.Variable xvar) { > + Assert.assertTrue("x".equals(xvar.getVariable())); > + } catch(JexlException xother) { > + Assert.assertTrue(xother != null); > + } finally { > + options.setAntish(true); > + } > > result = null; > script = JEXL.createScript("x?.y?.z"); > diff --git a/src/test/java/org/apache/commons/jexl3/Issues300Test.java > b/src/test/java/org/apache/commons/jexl3/Issues300Test.java > index d2b45ec..913133b 100644 > --- a/src/test/java/org/apache/commons/jexl3/Issues300Test.java > +++ b/src/test/java/org/apache/commons/jexl3/Issues300Test.java > @@ -324,25 +324,24 @@ public class Issues300Test { > Assert.assertEquals(52, result); > } > > - public static class ClazzB { > - public int methodB() { > - return 42; > - } > - } > - public static class ClazzA { > - public ClazzB methodA() { > - return new ClazzB(); > - } > - } > > @Test > - public void test317Tentative() throws Exception { > + public void test317() throws Exception { > JexlEngine jexl = new JexlBuilder().strict(true).create(); > JexlContext ctxt = new MapContext(); > JexlScript script; > Object result; > - script = jexl.createScript("x.methodA().methodB()", "x"); > - result = script.execute(ctxt, new ClazzA()); > + JexlInfo info = new JexlInfo("test317", 1, 1); > + script = jexl.createScript(info, "var f = " > + + "()-> {x + x }; f", > + "x"); > + result = script.execute(ctxt, 21); > + Assert.assertTrue(result instanceof JexlScript); > + script = (JexlScript) result; > + info = JexlInfo.from(script); > + Assert.assertNotNull(info); > + Assert.assertEquals("test317", info.getName()); > + result = script.execute(ctxt, 21); > Assert.assertEquals(42, result); > } > } > diff --git a/src/test/java/org/apache/commons/jexl3/JXLTTest.java > b/src/test/java/org/apache/commons/jexl3/JXLTTest.java > index c59193d..3986c2e 100644 > --- a/src/test/java/org/apache/commons/jexl3/JXLTTest.java > +++ b/src/test/java/org/apache/commons/jexl3/JXLTTest.java > @@ -19,7 +19,6 @@ package org.apache.commons.jexl3; > import org.apache.commons.jexl3.internal.TemplateDebugger; > import org.apache.commons.jexl3.internal.TemplateScript; > import org.apache.commons.jexl3.internal.Debugger; > -import org.apache.commons.jexl3.internal.Options; > > import org.apache.commons.logging.Log; > import org.apache.commons.logging.LogFactory; > @@ -806,7 +805,7 @@ public class JXLTTest extends JexlTestCase { > } > > JexlOptions newOptions() { > - options = new Options(); > + options = new JexlOptions(); > return options; > } > } > diff --git a/src/test/java/org/apache/commons/jexl3/JexlEvalContext.java > b/src/test/java/org/apache/commons/jexl3/JexlEvalContext.java > index 55fdcad..f0c233c 100644 > --- a/src/test/java/org/apache/commons/jexl3/JexlEvalContext.java > +++ b/src/test/java/org/apache/commons/jexl3/JexlEvalContext.java > @@ -19,7 +19,6 @@ package org.apache.commons.jexl3; > import java.util.Collections; > import java.util.Map; > import org.apache.commons.jexl3.annotations.NoJexl; > -import org.apache.commons.jexl3.internal.Options; > > /** > * A JEXL evaluation environment wrapping variables, namespace and > options. > @@ -35,7 +34,7 @@ public class JexlEvalContext implements > /** The namespace. */ > private final JexlContext.NamespaceResolver ns; > /** The options. */ > - private final JexlOptions options = new Options(); > + private final JexlOptions options = new JexlOptions(); > > > > diff --git a/src/test/java/org/apache/commons/jexl3/JexlTestCase.java > b/src/test/java/org/apache/commons/jexl3/JexlTestCase.java > index f8d00d3..294ea4a 100644 > --- a/src/test/java/org/apache/commons/jexl3/JexlTestCase.java > +++ b/src/test/java/org/apache/commons/jexl3/JexlTestCase.java > @@ -35,7 +35,7 @@ public class JexlTestCase { > // important can be identified by the builder calling lexical(...). > static { > //JexlBuilder.setDefaultOptions("+safe", "-lexical"); > - JexlBuilder.setDefaultOptions("-safe", "+lexical"); > + JexlOptions.setDefaultFlags("-safe", "+lexical"); > } > /** No parameters signature for test run. */ > private static final Class<?>[] NO_PARMS = {}; > diff --git a/src/test/java/org/apache/commons/jexl3/LexicalTest.java > b/src/test/java/org/apache/commons/jexl3/LexicalTest.java > index cf8943e..891393a 100644 > --- a/src/test/java/org/apache/commons/jexl3/LexicalTest.java > +++ b/src/test/java/org/apache/commons/jexl3/LexicalTest.java > @@ -19,6 +19,7 @@ package org.apache.commons.jexl3; > import java.io.StringReader; > import java.io.StringWriter; > import java.util.Set; > +import org.apache.commons.jexl3.internal.LexicalScope; > import org.junit.Assert; > import org.junit.Test; > > @@ -344,4 +345,46 @@ public class LexicalTest { > Assert.assertNotNull(xany); > } > } > + > + @Test > + public void testPragmaOptions() throws Exception { > + // same as 6d but using a pragma > + String str = "#pragma jexl.options '+strict +lexical > +lexicalShade -safe'\n" > + + "i = 0; for (var i : [42]) i; i"; > + JexlEngine jexl = new JexlBuilder().strict(false).create(); > + JexlScript e = jexl.createScript(str); > + JexlContext ctxt = new MapContext(); > + try { > + Object o = e.execute(ctxt); > + Assert.fail("i should be shaded"); > + } catch (JexlException xany) { > + Assert.assertNotNull(xany); > + } > + } > + > + @Test > + public void testPragmaNoop() throws Exception { > + // unknow pragma > + String str = "#pragma jexl.options 'no effect'\ni = -42; for (var > i : [42]) i; i"; > + JexlEngine jexl = new > JexlBuilder().lexical(false).strict(true).create(); > + JexlScript e = jexl.createScript(str); > + JexlContext ctxt = new MapContext(); > + Object result = e.execute(ctxt); > + Assert.assertEquals(42, result); > + } > + > + > + @Test > + public void testScopeFrame() throws Exception { > + LexicalScope scope = new LexicalScope(null); > + for(int i = 0; i < 128; i += 2) { > + Assert.assertTrue(scope.declareSymbol(i)); > + Assert.assertFalse(scope.declareSymbol(i)); > + } > + for(int i = 0; i < 128; i += 2) { > + Assert.assertTrue(scope.hasSymbol(i)); > + Assert.assertFalse(scope.hasSymbol(i + 1)); > + } > + } > + > } > >
