Class AbstractParser

    • Field Detail

      • expr

        protected char[] expr
      • cursor

        protected int cursor
      • start

        protected int start
      • length

        protected int length
      • end

        protected int end
      • st

        protected int st
      • fields

        protected int fields
      • greedy

        protected boolean greedy
      • lastWasIdentifier

        protected boolean lastWasIdentifier
      • lastWasLineLabel

        protected boolean lastWasLineLabel
      • lastWasComment

        protected boolean lastWasComment
      • compileMode

        protected boolean compileMode
      • literalOnly

        protected int literalOnly
      • lastLineStart

        protected int lastLineStart
      • line

        protected int line
      • lastNode

        protected ASTNode lastNode
      • EX_PRECACHE

        private static final java.util.WeakHashMap<java.lang.String,​char[]> EX_PRECACHE
      • LITERALS

        public static java.util.HashMap<java.lang.String,​java.lang.Object> LITERALS
      • CLASS_LITERALS

        public static java.util.HashMap<java.lang.String,​java.lang.Object> CLASS_LITERALS
      • OPERATORS

        public static java.util.HashMap<java.lang.String,​java.lang.Integer> OPERATORS
      • ctx

        protected java.lang.Object ctx
      • debugSymbols

        protected boolean debugSymbols
      • LEVEL_2_MULTI_STATEMENT

        public static final int LEVEL_2_MULTI_STATEMENT
        See Also:
        Constant Field Values
    • Constructor Detail

      • AbstractParser

        protected AbstractParser()
      • AbstractParser

        protected AbstractParser​(ParserContext pCtx)
    • Method Detail

      • setupParser

        public static void setupParser()
        This method is internally called by the static initializer for AbstractParser in order to setup the parser. The static initialization populates the operator and literal tables for the parser. In some situations, like OSGi, it may be necessary to utilize this manually.
      • nextTokenSkipSymbols

        protected ASTNode nextTokenSkipSymbols()
      • nextToken

        protected ASTNode nextToken()
        Retrieve the next token in the expression.
        Returns:
        -
      • handleUnion

        protected ASTNode handleUnion​(ASTNode node)
        Handle a union between a closed statement and a residual property chain.
        Parameters:
        node - an ast node
        Returns:
        ASTNode
      • createOperator

        private ASTNode createOperator​(char[] expr,
                                       int start,
                                       int end)
        Create an operator node.
        Parameters:
        expr - an char[] containing the expression
        start - the start offet for the token
        end - the end offset for the token
        Returns:
        ASTNode
      • subArray

        private char[] subArray​(int start,
                                int end)
        Create a copy of an array based on a sub-range. Works faster than System.arrayCopy() for arrays shorter than 1000 elements in most cases, so the parser uses this internally.
        Parameters:
        start - the start offset
        end - the end offset
        Returns:
        an array
      • createPropertyToken

        private ASTNode createPropertyToken​(int st,
                                            int end)
        Generate a property token
        Parameters:
        st - the start offset
        end - the end offset
        Returns:
        an ast node
      • procTypedNode

        private ASTNode procTypedNode​(boolean decl)
        Process the current typed node
        Parameters:
        decl - node is a declaration or not
        Returns:
        and ast node
      • createBlockToken

        private ASTNode createBlockToken​(int condStart,
                                         int condEnd,
                                         int blockStart,
                                         int blockEnd,
                                         int type)
        Generate a code block token.
        Parameters:
        condStart - the start offset for the condition
        condEnd - the end offset for the condition
        blockStart - the start offset for the block
        blockEnd - the end offset for the block
        type - the type of block
        Returns:
        and ast node
      • captureCodeBlock

        private ASTNode captureCodeBlock​(int type)
        Capture a code block by type.
        Parameters:
        type - the block type
        Returns:
        an ast node
      • _captureBlock

        private ASTNode _captureBlock​(ASTNode node,
                                      char[] expr,
                                      boolean cond,
                                      int type)
      • ifThenElseBlockContinues

        protected boolean ifThenElseBlockContinues()
        Checking from the current cursor position, check to see if the if-then-else block continues.
        Returns:
        boolean value
      • tokenContinues

        protected boolean tokenContinues()
        Checking from the current cursor position, check to see if we're inside a contiguous identifier.
        Returns:
        -
      • expectEOS

        protected void expectEOS()
        The parser should find a statement ending condition when this is called, otherwise everything should blow up.
      • isNextIdentifier

        protected boolean isNextIdentifier()
        Checks to see if the next part of the statement is an identifier part.
        Returns:
        boolean true if next part is identifier part.
      • captureToEOS

        protected void captureToEOS()
        Capture from the current cursor position, to the end of the statement.
      • captureToEOSorEOL

        protected void captureToEOSorEOL()
        From the current cursor position, capture to the end of statement, or the end of line, whichever comes first.
      • captureIdentifier

        protected void captureIdentifier()
        Capture to the end of the current identifier under the cursor.
      • captureToEOT

        protected void captureToEOT()
        From the current cursor position, capture to the end of the current token.
      • lastNonWhite

        protected boolean lastNonWhite​(char c)
      • trimLeft

        protected int trimLeft​(int pos)
        From the specified cursor position, trim out any whitespace between the current position and the end of the last non-whitespace character.
        Parameters:
        pos - - current position
        Returns:
        new position.
      • trimRight

        protected int trimRight​(int pos)
        From the specified cursor position, trim out any whitespace between the current position and beginning of the first non-whitespace character.
        Parameters:
        pos - -
        Returns:
        -
      • skipWhitespace

        protected void skipWhitespace()
        If the cursor is currently pointing to whitespace, move the cursor forward to the first non-whitespace character, but account for carriage returns in the script (updates parser field: line).
      • captureToNextTokenJunction

        protected void captureToNextTokenJunction()
        From the current cursor position, capture to the end of the next token junction.
      • trimWhitespace

        protected void trimWhitespace()
        From the current cursor position, trim backward over any whitespace to the first non-whitespace character.
      • setExpression

        protected void setExpression​(java.lang.String expression)
        Set and finesse the expression, trimming an leading or proceeding whitespace.
        Parameters:
        expression - the expression
      • setExpression

        protected void setExpression​(char[] expression)
        Set and finesse the expression, trimming an leading or proceeding whitespace.
        Parameters:
        expression - the expression
      • lookToLast

        protected char lookToLast()
        Return the previous non-whitespace character.
        Returns:
        -
      • lookBehind

        protected char lookBehind()
        Return the last character (delta -1 of cursor position).
        Returns:
        -
      • lookAhead

        protected char lookAhead()
        Return the next character (delta 1 of cursor position).
        Returns:
        -
      • lookAhead

        protected char lookAhead​(int range)
        Return the character, forward of the currrent cursor position based on the specified range delta.
        Parameters:
        range - -
        Returns:
        -
      • isNextIdentifierOrLiteral

        protected boolean isNextIdentifierOrLiteral()
        Returns true if the next is an identifier or literal.
        Returns:
        true of false
      • incNextNonBlank

        public int incNextNonBlank()
        Increment one cursor position, and move cursor to next non-blank part.
        Returns:
        cursor position
      • nextNonBlank

        public int nextNonBlank()
        Move to next cursor position from current cursor position.
        Returns:
        cursor position
      • expectNextChar_IW

        public void expectNextChar_IW​(char c)
        Expect the next specified character or fail
        Parameters:
        c - character
      • isStatementNotManuallyTerminated

        protected boolean isStatementNotManuallyTerminated()
        NOTE: This method assumes that the current position of the cursor is at the end of a logical statement, to begin with. Determines whether or not the logical statement is manually terminated with a statement separator (';').
        Returns:
        -
      • addFatalError

        protected void addFatalError​(java.lang.String message)
      • addFatalError

        protected void addFatalError​(java.lang.String message,
                                     int start)
      • setLanguageLevel

        public static void setLanguageLevel​(int level)
      • loadLanguageFeaturesByLevel

        public static java.util.HashMap<java.lang.String,​java.lang.Integer> loadLanguageFeaturesByLevel​(int languageLevel)
      • isArithmeticOperator

        protected static boolean isArithmeticOperator​(int operator)
      • arithmeticFunctionReduction

        protected int arithmeticFunctionReduction​(int operator)
        Reduce the current operations on the stack.
        Parameters:
        operator - the operator
        Returns:
        a stack control code
      • dreduce

        private void dreduce()
      • reduce

        protected void reduce()
        This method is called when we reach the point where we must subEval a trinary operation in the expression. (ie. val1 op val2). This is not the same as a binary operation, although binary operations would appear to have 3 structures as well. A binary structure (or also a junction in the expression) compares the current state against 2 downrange structures (usually an op and a val).
      • reduceNumeric

        private void reduceNumeric​(int operator)
      • reduce

        private void reduce​(int op1,
                            int operator,
                            int op2)
      • reduce

        private void reduce​(int op1,
                            int operator,
                            long op2)
      • reduce

        private void reduce​(long op1,
                            int operator,
                            int op2)
      • reduce

        private void reduce​(long op1,
                            int operator,
                            long op2)
      • getCursor

        public int getCursor()
        Specified by:
        getCursor in interface Parser
      • getExpression

        public char[] getExpression()
        Specified by:
        getExpression in interface Parser
      • asInt

        private static int asInt​(java.lang.Object o)