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
protected ParserRuleContext	_ctx The RuleContext object for the currently executing rule.
protected ANTLRErrorStrategy	_errHandler
protected TokenStream	_input
protected List<ParseTreeListener>	_parseListeners If the listener is non-null, trigger enter and exit rule events *during* the parse.
protected int	_syntaxErrors Did the recognizer encounter a syntax error? Track how many.
protected Parser.TraceListener	_tracer

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) Provide a listener that gets notified about token matches, and rule entry/exit events DURING the parse.
Token	consume() Consume the current symbol and return it.
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()
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() Compute the set of valid tokens reachable from the current position in the parse.
IntervalSet	getExpectedTokensWithinCurrentRule()
TokenStream	getInputStream()
ParserRuleContext	getInvokingContext(int ruleIndex)
int	getNumberOfSyntaxErrors() Get number of recognition errors (lexer, parser, tree parser).
List<ParseTreeListener>	getParseListeners()
ParserRuleContext	getRuleContext()
List<String>	getRuleInvocationStack() Return List of the rule names in your parser instance leading up to a call to the current rule.
List<String>	getRuleInvocationStack(RuleContext p)
String	getSourceName()
TokenStream	getTokenStream()
boolean	getTrimParseTree()
boolean	inContext(String context)
boolean	isExpectedToken(int symbol)
Token	match(int ttype) Match current input symbol against ttype.
Token	matchWildcard()
void	notifyErrorListeners(String msg)
void	notifyErrorListeners(Token offendingToken, String msg, RecognitionException e)
void	pushNewRecursionContext(ParserRuleContext localctx, int state, int ruleIndex)
void	removeParseListener(ParseTreeListener l)
void	removeParseListeners()
void	reset() reset the parser's state
void	setBuildParseTree(boolean buildParseTrees) Track the RuleContext objects during the parse and hook them up using the 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.
List<String>	toStrings(List<? extends Token> tokens) A convenience method for use most often with template rewrites.
void	triggerEnterRuleEvent() Notify any parse listeners (implemented as ParseTreeListener's) of an enter rule event.
void	triggerExitRuleEvent() Notify any parse listeners (implemented as ParseTreeListener's) 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

protected ANTLRErrorStrategy _errHandler

_input

protected TokenStream _input

_ctx

protected ParserRuleContext _ctx

The RuleContext object for the currently executing rule. This must be non-null during parsing, but is initially null. When somebody calls the start rule, this gets set to the root context.

_buildParseTrees

protected boolean _buildParseTrees

_tracer

protected Parser.TraceListener _tracer

_parseListeners

protected List<ParseTreeListener> _parseListeners

If the listener is non-null, trigger enter and exit rule events *during* the parse. This is typically done only when not building parse trees for later visiting. We either trigger events during the parse or during tree walks later. Both could be done. Not intended for average user!!! Most people should use ParseTreeListener with ParseTreeWalker.

See Also:

ParseTreeWalker

_syntaxErrors

protected int _syntaxErrors

Did the recognizer encounter a syntax error? Track how many.

Constructor Detail

Parser

public Parser(TokenStream input)

Method Detail

reset

public void reset()

reset the parser's state

match

public Token match(int ttype)
            throws RecognitionException

Match current input symbol against ttype. Attempt single token insertion or deletion error recovery. If that fails, throw MismatchedTokenException.

Throws:

RecognitionException

matchWildcard

public Token matchWildcard()
                    throws RecognitionException

Throws:

RecognitionException

setBuildParseTree

public void setBuildParseTree(boolean buildParseTrees)

Track the RuleContext objects during the parse and hook them up using the children list so that it forms a parse tree. The RuleContext returned from the start rule represents the root of the parse tree. To built parse trees, all we have to do is put a hook in setState() and enterRule(). In setState(), we add tokens to the current context as children. By the time we get to enterRule(), we are already in an invoked rule so we add this context as a child of the parent (invoking) context. Simple and effective. 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 somebody's children list. Contexts are then not candidates for garbage collection.

getBuildParseTree

public boolean getBuildParseTree()

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)

Provide a listener that gets notified about token matches, and rule entry/exit events DURING the parse. It's a little bit weird for left recursive rule entry events but it's deterministic. THIS IS ONLY FOR ADVANCED USERS. Please give your ParseTreeListener to a ParseTreeWalker instead of giving it to the parser!!!!

removeParseListener

public void removeParseListener(ParseTreeListener l)

removeParseListeners

public void removeParseListeners()

triggerEnterRuleEvent

public void triggerEnterRuleEvent()

Notify any parse listeners (implemented as ParseTreeListener's) of an enter rule event. This is not involved with parse tree walking in any way; it's just reusing the ParseTreeListener interface. This is not for the average user.

triggerExitRuleEvent

public void triggerExitRuleEvent()

Notify any parse listeners (implemented as ParseTreeListener's) of an exit rule event. This is not involved with parse tree walking in any way; it's just reusing the ParseTreeListener interface. This is not for the average user.

getNumberOfSyntaxErrors

public int getNumberOfSyntaxErrors()

Get number of recognition errors (lexer, parser, tree parser). Each recognizer tracks its own number. So parser and lexer each have separate count. Does not count the spurious errors found between an error and next valid token match See also reportError()

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

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 void notifyErrorListeners(String msg)

notifyErrorListeners

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

consume

public Token consume()

Consume the current symbol and return it. E.g., given the following input with A being the current lookahead symbol: A B ^ this function moves the cursor to B and returns A. If the parser is creating parse trees, the current symbol would also be added as a child to the current context (node). Trigger listener events if there's a listener.

addContextToParseTree

protected void addContextToParseTree()

enterRule

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

Always called by generated parsers upon entry to a rule. This occurs after the new context has been pushed. Access field _ctx get the current context. This is flexible because users do not have to regenerate parsers to get trace facilities.

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)

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)

getExpectedTokens

public IntervalSet getExpectedTokens()

Compute the set of valid tokens reachable from the current position in the parse.

getExpectedTokensWithinCurrentRule

public IntervalSet getExpectedTokensWithinCurrentRule()

getRuleContext

public ParserRuleContext getRuleContext()

getRuleInvocationStack

public List<String> getRuleInvocationStack()

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

toStrings

public List<String> toStrings(List<? extends Token> tokens)

A convenience method for use most often with template rewrites. Convert a List to List

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.