org.antlr.v4.runtime

Class Parser

java.lang.Object

org.antlr.v4.runtime.Recognizer<Token,ParserATNSimulator>

org.antlr.v4.runtime.Parser

public abstract class Parser
extends Recognizer<Token,ParserATNSimulator>

This is all the parsing support code essentially; most of it is error recovery stuff.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	Parser.TraceListener
static class	Parser.TrimToSizeListener

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	_buildParseTrees Specifies whether or not the parser should construct a parse tree during the parsing process.
protected ParserRuleContext	_ctx The ParserRuleContext object for the currently executing rule.
protected ANTLRErrorStrategy	_errHandler The error handling strategy for the parser.
protected TokenStream	_input The input stream.
protected List<ParseTreeListener>	_parseListeners The list of ParseTreeListener listeners registered to receive events during the parse.
protected int	_syntaxErrors The number of syntax errors reported during parsing.

Fields inherited from class org.antlr.v4.runtime.Recognizer

_interp, EOF

Constructor Summary

Constructors

Constructor and Description
Parser(TokenStream input)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	addContextToParseTree()
void	addParseListener(ParseTreeListener listener) Registers listener to receive events during the parsing process.
Token	consume() Consume and return the current symbol.
void	dumpDFA() For debugging and other purposes.
void	enterOuterAlt(ParserRuleContext localctx, int altNum)
void	enterRecursionRule(ParserRuleContext localctx, int ruleIndex)
void	enterRule(ParserRuleContext localctx, int state, int ruleIndex) Always called by generated parsers upon entry to a rule.
void	exitRule()
boolean	getBuildParseTree() Gets whether or not a complete parse tree will be constructed while parsing.
ParserRuleContext	getContext()
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.
List<String>	getDFAStrings() For debugging and other purposes.
ANTLRErrorStrategy	getErrorHandler()
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.
IntervalSet	getExpectedTokensWithinCurrentRule()
TokenStream	getInputStream()
ParserRuleContext	getInvokingContext(int ruleIndex)
int	getNumberOfSyntaxErrors() Gets the number of syntax errors reported during parsing.
List<ParseTreeListener>	getParseListeners()
ParserRuleContext	getRuleContext()
List<String>	getRuleInvocationStack() Return List<String> of the rule names in your parser instance leading up to a call to the current rule.
List<String>	getRuleInvocationStack(RuleContext p)
String	getSourceName()
TokenFactory<?>	getTokenFactory()
TokenStream	getTokenStream()
boolean	getTrimParseTree()
boolean	inContext(String context)
boolean	isExpectedToken(int symbol) Checks whether or not symbol can follow the current state in the ATN.
Token	match(int ttype) Match current input symbol against ttype.
Token	matchWildcard() Match current input symbol as a wildcard.
void	notifyErrorListeners(String msg)
void	notifyErrorListeners(Token offendingToken, String msg, RecognitionException e)
void	pushNewRecursionContext(ParserRuleContext localctx, int state, int ruleIndex) Like enterRule(org.antlr.v4.runtime.ParserRuleContext, int, int) but for recursive rules.
void	removeParseListener(ParseTreeListener listener) Remove listener from the list of parse listeners.
void	removeParseListeners() Remove all parse listeners.
void	reset() reset the parser's state
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.
void	setErrorHandler(ANTLRErrorStrategy handler)
void	setInputStream(IntStream input)
void	setTokenFactory(TokenFactory<?> factory) Tell our token source and error strategy about a new way to create tokens.
void	setTokenStream(TokenStream input) Set the token stream and reset the parser.
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.
void	setTrimParseTree(boolean trimParseTrees) Trim the internal lists of the parse tree during parsing to conserve memory.
protected void	triggerEnterRuleEvent() Notify any parse listeners of an enter rule event.
protected void	triggerExitRuleEvent() Notify any parse listeners of an exit rule event.
void	unrollRecursionContexts(ParserRuleContext _parentctx)

Methods inherited from class org.antlr.v4.runtime.Recognizer

action, addErrorListener, getATN, getErrorHeader, getErrorListenerDispatch, getErrorListeners, getGrammarFileName, getInterpreter, getRuleNames, getState, getTokenErrorDisplay, getTokenNames, removeErrorListener, removeErrorListeners, sempred, setInterpreter, setState

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

_errHandler

@NotNull
protected ANTLRErrorStrategy _errHandler

The error handling strategy for the parser. The default value is a new instance of DefaultErrorStrategy.

See Also:

getErrorHandler(), setErrorHandler(org.antlr.v4.runtime.ANTLRErrorStrategy)

_input

protected TokenStream _input

The input stream.

See Also:

getInputStream(), setInputStream(org.antlr.v4.runtime.IntStream)

_ctx

protected ParserRuleContext _ctx

The ParserRuleContext object for the currently executing rule. This is always non-null during the parsing process.

_buildParseTrees

protected boolean _buildParseTrees

Specifies whether or not the parser should construct a parse tree during the parsing process. The default value is true.

See Also:

getBuildParseTree(), setBuildParseTree(boolean)

_parseListeners

@Nullable
protected List<ParseTreeListener> _parseListeners

The list of ParseTreeListener listeners registered to receive events during the parse.

See Also:

addParseListener(org.antlr.v4.runtime.tree.ParseTreeListener)

_syntaxErrors

protected int _syntaxErrors

The number of syntax errors reported during parsing. This value is incremented each time notifyErrorListeners(java.lang.String) is called.

Constructor Detail

Parser

public Parser(TokenStream input)

Method Detail

reset

public void reset()

reset the parser's state

match

@NotNull
public Token match(int ttype)
            throws RecognitionException

Match current input symbol against ttype. If the symbol type matches, ANTLRErrorStrategy.reportMatch(org.antlr.v4.runtime.Parser) and consume() are called to complete the match process.

If the symbol type does not match, ANTLRErrorStrategy.recoverInline(org.antlr.v4.runtime.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(org.antlr.v4.runtime.Parser) is -1, the symbol is added to the parse tree by calling ParserRuleContext.addErrorNode(org.antlr.v4.runtime.Token).

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

@NotNull
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(org.antlr.v4.runtime.Parser) and consume() are called to complete the match process.

If the symbol type does not match, ANTLRErrorStrategy.recoverInline(org.antlr.v4.runtime.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(org.antlr.v4.runtime.Parser) is -1, the symbol is added to the parse tree by calling ParserRuleContext.addErrorNode(org.antlr.v4.runtime.Token).

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

@NotNull
public List<ParseTreeListener> getParseListeners()

addParseListener

public void addParseListener(@NotNull
                    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:

addParseListener(org.antlr.v4.runtime.tree.ParseTreeListener)

removeParseListeners

public void removeParseListeners()

Remove all parse listeners.

See Also:

addParseListener(org.antlr.v4.runtime.tree.ParseTreeListener)

triggerEnterRuleEvent

protected void triggerEnterRuleEvent()

Notify any parse listeners of an enter rule event.

See Also:

addParseListener(org.antlr.v4.runtime.tree.ParseTreeListener)

triggerExitRuleEvent

protected void triggerExitRuleEvent()

Notify any parse listeners of an exit rule event.

See Also:

addParseListener(org.antlr.v4.runtime.tree.ParseTreeListener)

getNumberOfSyntaxErrors

public int getNumberOfSyntaxErrors()

Gets the number of syntax errors reported during parsing. This value is incremented each time notifyErrorListeners(java.lang.String) is called.

See Also:

notifyErrorListeners(java.lang.String)

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>

getErrorHandler

@NotNull
public ANTLRErrorStrategy getErrorHandler()

setErrorHandler

public void setErrorHandler(@NotNull
                   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,
                        @Nullable
                        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(Token), and ParseTreeListener.visitTerminal(org.antlr.v4.runtime.tree.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 ParserRuleContext.addErrorNode(Token), and ParseTreeListener.visitErrorNode(org.antlr.v4.runtime.tree.ErrorNode) is called on any parse listeners.

addContextToParseTree

protected void addContextToParseTree()

enterRule

public void enterRule(@NotNull
             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)

enterRecursionRule

public void enterRecursionRule(ParserRuleContext localctx,
                      int ruleIndex)

pushNewRecursionContext

public void pushNewRecursionContext(ParserRuleContext localctx,
                           int state,
                           int ruleIndex)

Like enterRule(org.antlr.v4.runtime.ParserRuleContext, int, int) but for recursive rules.

unrollRecursionContexts

public void unrollRecursionContexts(ParserRuleContext _parentctx)

getInvokingContext

public ParserRuleContext getInvokingContext(int ruleIndex)

getContext

public ParserRuleContext getContext()

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.

getExpectedTokens

@NotNull
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:

ATN.getExpectedTokens(int, RuleContext)

getExpectedTokensWithinCurrentRule

@NotNull
public IntervalSet getExpectedTokensWithinCurrentRule()

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()

For debugging and other purposes.

getSourceName

public String getSourceName()

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.