Package org.apache.commons.jexl3.parser

Class JexlParser

java.lang.Object
org.apache.commons.jexl3.parser.StringParser
org.apache.commons.jexl3.parser.JexlParser
Direct Known Subclasses:
Parser
public abstract class JexlParser extends StringParser
The base class for parsing, manages the parameter/local variable frame.

  • Field Details

    • featureController

      protected final FeatureController featureController
      The associated controller.

    • info

      protected JexlInfo info
      The basic source info.

    • source

      protected String source
      The source being processed.

    • scope

      protected Scope scope
      The map of named registers aka script parameters.

      Each parameter is associated to a register and is materialized as an offset in the registers array used during evaluation.

    • scopes

      protected final Deque<Scope> scopes
      When parsing inner functions/lambda, need to stack the scope (sic).

    • pragmas

      protected Map<String,Object> pragmas
      The list of pragma declarations.

    • namespaces

      protected Set<String> namespaces
      The known namespaces.

    • loopCount

      protected int loopCount
      The number of nested loops.

    • loopCounts

      protected final Deque<Integer> loopCounts
      Stack of parsing loop counts.

    • block

      protected JexlParser.LexicalUnit block
      The current lexical block.

    • blocks

      protected final Deque<JexlParser.LexicalUnit> blocks
      Stack of lexical blocks.

    • blockScopes

      protected final Map<JexlParser.LexicalUnit,Scope> blockScopes
      The map of lexical to functional blocks.

    • PRAGMA_OPTIONS

      public static final String PRAGMA_OPTIONS
      The name of the options pragma.
      See Also:

    • PRAGMA_JEXLNS

      public static final String PRAGMA_JEXLNS
      The prefix of a namespace pragma.
      See Also:

    • PRAGMA_MODULE

      public static final String PRAGMA_MODULE
      The prefix of a module pragma.
      See Also:

    • PRAGMA_IMPORT

      public static final String PRAGMA_IMPORT
      The import pragma.
      See Also:

    • ASSIGN_NODES

      private static final Set<Class<? extends JexlNode>> ASSIGN_NODES
      The set of assignment operators as classes.

  • Constructor Details

    • JexlParser

      public JexlParser()

  • Method Details

    • cleanup

      protected void cleanup(JexlFeatures features)
      Cleanup.
      Parameters:
      features - the feature set to restore if any

    • stringify

      protected static String stringify(Iterable<String> lstr)
      Utility function to create '.' separated string from a list of string.
      Parameters:
      lstr - the list of strings
      Returns:
      the dotted version

    • readSourceLine

      protected static String readSourceLine(String src, int lineno)
      Read a given source line.
      Parameters:
      src - the source
      lineno - the line number
      Returns:
      the line

    • allowRegisters

      public void allowRegisters(boolean registers)
      Internal, for debug purpose only.
      Parameters:
      registers - whether register syntax is recognized by this parser

    • setFeatures

      protected void setFeatures(JexlFeatures features)
      Sets a new set of options.
      Parameters:
      features - the parser features

    • getFeatures

      protected JexlFeatures getFeatures()
      Returns:
      the current set of features active during parsing

    • controlPragmaAnywhere

      protected void controlPragmaAnywhere()
      Disables pragma feature is pragma-anywhere feature is disabled.

    • getScope

      protected Scope getScope()
      Gets the frame used by this parser.

      Since local variables create new symbols, it is important to regain access after parsing to known which / how-many registers are needed.

      Returns:
      the named register map

    • pushScope

      protected void pushScope()
      Create a new local variable scope and push it as current.

    • popScope

      protected void popScope()
      Pops back to previous local variable scope.

    • getUnit

      protected JexlParser.LexicalUnit getUnit()
      Gets the lexical unit used by this parser.
      Returns:
      the named register map

    • pushUnit

      protected void pushUnit(JexlParser.LexicalUnit unit)
      Pushes a new lexical unit.
      Parameters:
      unit - the new lexical unit

    • popUnit

      protected void popUnit(JexlParser.LexicalUnit unit)
      Restores the previous lexical unit.
      Parameters:
      unit - restores the previous lexical scope

    • isSymbolDeclared

      private boolean isSymbolDeclared(JexlNode.Info info, int symbol)
      Checks if a symbol is defined in lexical scopes.

      This works with parsed scripts in template resolution only.

      Parameters:
      info - an info linked to a node
      symbol - the symbol number
      Returns:
      true if symbol accessible in lexical scope

    • isVariable

      protected boolean isVariable(String name)
      Checks whether an identifier is a local variable or argument.
      Parameters:
      name - the variable name
      Returns:
      true if a variable with that name was declared

    • checkVariable

      protected String checkVariable(ASTIdentifier identifier, String name)
      Checks whether an identifier is a local variable or argument, ie a symbol, stored in a register.
      Parameters:
      identifier - the identifier
      name - the identifier name
      Returns:
      the image

    • allowVariable

      protected boolean allowVariable(String image)
      Whether a given variable name is allowed.
      Parameters:
      image - the name
      Returns:
      true if allowed, false if reserved

    • declareSymbol

      private boolean declareSymbol(int symbol)
      Declares a symbol.
      Parameters:
      symbol - the symbol index
      Returns:
      true if symbol can be declared in lexical scope, false (error) if it is already declared

    • declareFunction

      protected void declareFunction(ASTVar variable, Token token)
      Declares a local function.
      Parameters:
      variable - the identifier used to declare
      token - the variable name toekn

    • declareVariable

      protected void declareVariable(ASTVar variable, Token token, boolean lexical, boolean constant)
      Declares a local variable.

      This method creates an new entry in the symbol map.

      Parameters:
      variable - the identifier used to declare
      lexical - whether the symbol is lexical
      constant - whether the symbol is constant
      token - the variable name toekn

    • declareParameter

      protected void declareParameter(Token token, boolean lexical, boolean constant)
      Declares a local parameter.

      This method creates an new entry in the symbol map.

      Parameters:
      token - the parameter name token
      lexical - whether the parameter is lexical or not
      constant - whether the parameter is constant or not

    • declarePragma

      protected void declarePragma(String key, Object value)
      Adds a pragma declaration.
      Parameters:
      key - the pragma key
      value - the pragma value

    • isDeclaredNamespace

      protected boolean isDeclaredNamespace(Token token, Token colon)
      Checks whether a name identifies a declared namespace.
      Parameters:
      token - the namespace token
      Returns:
      true if the name qualifies a namespace

    • Identifier

      protected void Identifier(boolean top) throws ParseException
      Default implementation does nothing but is overridden by generated code.
      Parameters:
      top - whether the identifier is beginning an l/r value
      Throws:
      ParseException - subclasses may throw this

    • getToken

      protected abstract Token getToken(int index)
      Overridden in actual parser to access tokens stack.
      Parameters:
      index - 0 to get current token
      Returns:
      the token on the stack

    • jjtreeOpenNodeScope

      protected void jjtreeOpenNodeScope(JexlNode node)
      Called by parser at beginning of node construction.
      Parameters:
      node - the node

    • jjtreeCloseNodeScope

      protected void jjtreeCloseNodeScope(JexlNode node)
      Called by parser at end of node construction.

      Detects "Ambiguous statement" and 'non-left value assignment'.

      Parameters:
      node - the node
      Throws:
      JexlException.Parsing - when parsing fails

    • isConstant

      private boolean isConstant(int symbol)
      Checks whether a symbol has been declared as a const in the current stack of lexical units.
      Parameters:
      symbol - the symbol
      Returns:
      true if constant, false otherwise

    • checkLambda

      protected void checkLambda(Token token)
      Check fat vs thin arrow syntax feature.
      Parameters:
      token - the arrow token

    • throwAmbiguousException

      protected void throwAmbiguousException(JexlNode node)
      Throws Ambiguous exception.

      Seeks the end of the ambiguous statement to recover.

      Parameters:
      node - the first token in ambiguous expression
      Throws:
      JexlException.Ambiguous - in all cases

    • throwFeatureException

      protected void throwFeatureException(int feature, JexlInfo info)
      Throws a feature exception.
      Parameters:
      feature - the feature code
      info - the exception surroundings
      Throws:
      JexlException.Feature - in all cases

    • throwFeatureException

      protected void throwFeatureException(int feature, Token trigger)
      Throws a feature exception.
      Parameters:
      feature - the feature code
      trigger - the token that triggered it
      Throws:
      JexlException.Parsing - if actual error token can not be found
      JexlException.Feature - in all other cases

    • throwParsingException

      protected void throwParsingException(Token parsed)
      Throws a parsing exception.
      Parameters:
      parsed - the token to report
      Throws:
      JexlException.Parsing - in all cases

    • errorToken

      protected static Token errorToken(Token... tokens)
      Pick the most significant token for error reporting.
      Parameters:
      tokens - the tokens to choose from
      Returns:
      the token