Class Parser

java.lang.Object
org.antlr.v4.runtime.Recognizer<Token, ParserATNSimulator>
org.antlr.v4.runtime.Parser
Direct Known Subclasses:
ParserInterpreter
public abstract class Parser extends Recognizer<Token, ParserATNSimulator>
This is all the parsing support code essentially; most of it is error recovery stuff.

  • Field Details

  • Constructor Details

  • Method Details

    • reset

      public void reset()
      reset the parser's state

    • match

      public Token match(int ttype) throws RecognitionException
      Match current input symbol against ttype. If the symbol type matches, ANTLRErrorStrategy.reportMatch(Parser) and consume() are called to complete the match process.

      If the symbol type does not match, ANTLRErrorStrategy.recoverInline(Parser) is called on the current error strategy to attempt recovery. If getBuildParseTree() is true and the token index of the symbol returned by ANTLRErrorStrategy.recoverInline(Parser) is -1, the symbol is added to the parse tree by calling createErrorNode(ParserRuleContext, Token) then ParserRuleContext.addErrorNode(ErrorNode).

      Parameters:
      ttype - the token type to match
      Returns:
      the matched symbol
      Throws:
      RecognitionException - if the current input symbol did not match ttype and the error strategy could not recover from the mismatched symbol

    • matchWildcard

      public Token matchWildcard() throws RecognitionException
      Match current input symbol as a wildcard. If the symbol type matches (i.e. has a value greater than 0), ANTLRErrorStrategy.reportMatch(Parser) and consume() are called to complete the match process.

      If the symbol type does not match, ANTLRErrorStrategy.recoverInline(Parser) is called on the current error strategy to attempt recovery. If getBuildParseTree() is true and the token index of the symbol returned by ANTLRErrorStrategy.recoverInline(Parser) is -1, the symbol is added to the parse tree by calling createErrorNode(ParserRuleContext, Token). then ParserRuleContext.addErrorNode(ErrorNode)

      Returns:
      the matched symbol
      Throws:
      RecognitionException - if the current input symbol did not match a wildcard and the error strategy could not recover from the mismatched symbol

    • setBuildParseTree

      public void setBuildParseTree(boolean buildParseTrees)
      Track the ParserRuleContext objects during the parse and hook them up using the ParserRuleContext.children list so that it forms a parse tree. The ParserRuleContext returned from the start rule represents the root of the parse tree.

      Note that if we are not building parse trees, rule contexts only point upwards. When a rule exits, it returns the context but that gets garbage collected if nobody holds a reference. It points upwards but nobody points at it.

      When we build parse trees, we are adding all of these contexts to ParserRuleContext.children list. Contexts are then not candidates for garbage collection.

    • getBuildParseTree

      public boolean getBuildParseTree()
      Gets whether or not a complete parse tree will be constructed while parsing. This property is true for a newly constructed parser.
      Returns:
      true if a complete parse tree will be constructed while parsing, otherwise false

    • setTrimParseTree

      public void setTrimParseTree(boolean trimParseTrees)
      Trim the internal lists of the parse tree during parsing to conserve memory. This property is set to false by default for a newly constructed parser.
      Parameters:
      trimParseTrees - true to trim the capacity of the ParserRuleContext.children list to its size after a rule is parsed.

    • getTrimParseTree

      public boolean getTrimParseTree()
      Returns:
      true if the ParserRuleContext.children list is trimmed using the default Parser.TrimToSizeListener during the parse process.

    • getParseListeners

      public List<ParseTreeListener> getParseListeners()

    • addParseListener

      public void addParseListener(ParseTreeListener listener)
      Registers listener to receive events during the parsing process.

      To support output-preserving grammar transformations (including but not limited to left-recursion removal, automated left-factoring, and optimized code generation), calls to listener methods during the parse may differ substantially from calls made by ParseTreeWalker.DEFAULT used after the parse is complete. In particular, rule entry and exit events may occur in a different order during the parse than after the parser. In addition, calls to certain rule entry methods may be omitted.

      With the following specific exceptions, calls to listener events are deterministic, i.e. for identical input the calls to listener methods will be the same.

      • Alterations to the grammar used to generate code may change the behavior of the listener calls.
      • Alterations to the command line options passed to ANTLR 4 when generating the parser may change the behavior of the listener calls.
      • Changing the version of the ANTLR Tool used to generate the parser may change the behavior of the listener calls.
      Parameters:
      listener - the listener to add
      Throws:
      NullPointerException - if listener is null

    • removeParseListener

      public void removeParseListener(ParseTreeListener listener)
      Remove listener from the list of parse listeners.

      If listener is null or has not been added as a parse listener, this method does nothing.

      Parameters:
      listener - the listener to remove
      See Also:

    • removeParseListeners

      public void removeParseListeners()
      Remove all parse listeners.
      See Also:

    • triggerEnterRuleEvent

      protected void triggerEnterRuleEvent()
      Notify any parse listeners of an enter rule event.
      See Also:

    • triggerExitRuleEvent

      protected void triggerExitRuleEvent()
      Notify any parse listeners of an exit rule event.
      See Also:

    • getNumberOfSyntaxErrors

      public int getNumberOfSyntaxErrors()
      Gets the number of syntax errors reported during parsing. This value is incremented each time notifyErrorListeners(String) is called.
      See Also:

    • getTokenFactory

      public TokenFactory<?> getTokenFactory()
      Specified by:
      getTokenFactory in class Recognizer<Token, ParserATNSimulator>

    • setTokenFactory

      public void setTokenFactory(TokenFactory<?> factory)
      Tell our token source and error strategy about a new way to create tokens.
      Specified by:
      setTokenFactory in class Recognizer<Token, ParserATNSimulator>

    • getATNWithBypassAlts

      public ATN getATNWithBypassAlts()
      The ATN with bypass alternatives is expensive to create so we create it lazily.
      Throws:
      UnsupportedOperationException - if the current parser does not implement the Recognizer.getSerializedATN() method.

    • compileParseTreePattern

      public ParseTreePattern compileParseTreePattern(String pattern, int patternRuleIndex)
      The preferred method of getting a tree pattern. For example, here's a sample use: 
      ParseTree t = parser.expr();
ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
ParseTreeMatch m = p.match(t);
String id = m.get("ID");

    • compileParseTreePattern

      public ParseTreePattern compileParseTreePattern(String pattern, int patternRuleIndex, Lexer lexer)
      The same as compileParseTreePattern(String, int) but specify a Lexer rather than trying to deduce it from this parser.

    • getErrorHandler

      public ANTLRErrorStrategy getErrorHandler()

    • setErrorHandler

      public void setErrorHandler(ANTLRErrorStrategy handler)

    • getInputStream

      public TokenStream getInputStream()
      Specified by:
      getInputStream in class Recognizer<Token, ParserATNSimulator>

    • setInputStream

      public final void setInputStream(IntStream input)
      Specified by:
      setInputStream in class Recognizer<Token, ParserATNSimulator>

    • getTokenStream

      public TokenStream getTokenStream()

    • setTokenStream

      public void setTokenStream(TokenStream input)
      Set the token stream and reset the parser.

    • getCurrentToken

      public Token getCurrentToken()
      Match needs to return the current input symbol, which gets put into the label for the associated token ref; e.g., x=ID.

    • notifyErrorListeners

      public final void notifyErrorListeners(String msg)

    • notifyErrorListeners

      public void notifyErrorListeners(Token offendingToken, String msg, RecognitionException e)

    • consume

      public Token consume()
      Consume and return the current symbol.

      E.g., given the following input with A being the current lookahead symbol, this function moves the cursor to B and returns A.

       A B
 ^
      If the parser is not in error recovery mode, the consumed symbol is added to the parse tree using ParserRuleContext.addChild(TerminalNode), and ParseTreeListener.visitTerminal(TerminalNode) is called on any parse listeners. If the parser is in error recovery mode, the consumed symbol is added to the parse tree using createErrorNode(ParserRuleContext, Token) then ParserRuleContext.addErrorNode(ErrorNode) and ParseTreeListener.visitErrorNode(ErrorNode) is called on any parse listeners.

    • createTerminalNode

      public TerminalNode createTerminalNode(ParserRuleContext parent, Token t)
      How to create a token leaf node associated with a parent. Typically, the terminal node to create is not a function of the parent.
      Since:
      4.7

    • createErrorNode

      public ErrorNode createErrorNode(ParserRuleContext parent, Token t)
      How to create an error node, given a token, associated with a parent. Typically, the error node to create is not a function of the parent.
      Since:
      4.7

    • addContextToParseTree

      protected void addContextToParseTree()

    • enterRule

      public void enterRule(ParserRuleContext localctx, int state, int ruleIndex)
      Always called by generated parsers upon entry to a rule. Access field _ctx get the current context.

    • exitRule

      public void exitRule()

    • enterOuterAlt

      public void enterOuterAlt(ParserRuleContext localctx, int altNum)

    • getPrecedence

      public final int getPrecedence()
      Get the precedence level for the top-most precedence rule.
      Returns:
      The precedence level for the top-most precedence rule, or -1 if the parser context is not nested within a precedence rule.

    • enterRecursionRule

      @Deprecated public void enterRecursionRule(ParserRuleContext localctx, int ruleIndex)
      Deprecated.
      Use enterRecursionRule(ParserRuleContext, int, int, int) instead.

    • enterRecursionRule

      public void enterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence)

    • pushNewRecursionContext

      public void pushNewRecursionContext(ParserRuleContext localctx, int state, int ruleIndex)
      Like enterRule(ParserRuleContext, int, int) but for recursive rules. Make the current context the child of the incoming localctx.

    • unrollRecursionContexts

      public void unrollRecursionContexts(ParserRuleContext _parentctx)

    • getInvokingContext

      public ParserRuleContext getInvokingContext(int ruleIndex)

    • getContext

      public ParserRuleContext getContext()

    • setContext

      public void setContext(ParserRuleContext ctx)

    • precpred

      public boolean precpred(RuleContext localctx, int precedence)
      Overrides:
      precpred in class Recognizer<Token, ParserATNSimulator>

    • inContext

      public boolean inContext(String context)

    • isExpectedToken

      public boolean isExpectedToken(int symbol)
      Checks whether or not symbol can follow the current state in the ATN. The behavior of this method is equivalent to the following, but is implemented such that the complete context-sensitive follow set does not need to be explicitly constructed. 
      return getExpectedTokens().contains(symbol);
      Parameters:
      symbol - the symbol type to check
      Returns:
      true if symbol can follow the current state in the ATN, otherwise false.

    • isMatchedEOF

      public boolean isMatchedEOF()

    • getExpectedTokens

      public IntervalSet getExpectedTokens()
      Computes the set of input symbols which could follow the current parser state and context, as given by Recognizer.getState() and getContext(), respectively.
      See Also:

    • getExpectedTokensWithinCurrentRule

      public IntervalSet getExpectedTokensWithinCurrentRule()

    • getRuleIndex

      public int getRuleIndex(String ruleName)
      Get a rule's index (i.e., RULE_ruleName field) or -1 if not found.

    • getRuleContext

      public ParserRuleContext getRuleContext()

    • getRuleInvocationStack

      public List<String> getRuleInvocationStack()
      Return List<String> of the rule names in your parser instance leading up to a call to the current rule. You could override if you want more details such as the file/line info of where in the ATN a rule is invoked. This is very useful for error messages.

    • getRuleInvocationStack

      public List<String> getRuleInvocationStack(RuleContext p)

    • getDFAStrings

      public List<String> getDFAStrings()
      For debugging and other purposes.

    • dumpDFA

      public void dumpDFA()

    • dumpDFA

      public void dumpDFA(PrintStream dumpStream)
      For debugging and other purposes.

    • getSourceName

      public String getSourceName()

    • getParseInfo

      public ParseInfo getParseInfo()
      Description copied from class: Recognizer
      If profiling during the parse/lex, this will return DecisionInfo records for each decision in recognizer in a ParseInfo object.
      Overrides:
      getParseInfo in class Recognizer<Token, ParserATNSimulator>

    • setProfile

      public void setProfile(boolean profile)
      Since:
      4.3

    • setTrace

      public void setTrace(boolean trace)
      During a parse is sometimes useful to listen in on the rule entry and exit events as well as token matches. This is for quick and dirty debugging.

    • isTrace

      public boolean isTrace()
      Gets whether a Parser.TraceListener is registered as a parse listener for the parser.
      See Also: