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:ParseTreeListener

the listener to add

Exceptions

NullPointerException:

if listener is null

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");

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

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
 ^

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

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

For debugging and other purposes.

Annotations

@Deprecated

Always called by generated parsers upon entry to a rule. Access field _ctx get the current context.

The ATN with bypass alternatives is expensive to create so we create it lazily.

Annotations

@NotNull

Exceptions

UnsupportedOperationException:

if the current parser does not implement the getSerializedATN() method.

Gets whether or not a complete parse tree will be constructed while parsing. This property is true for a newly constructed parser.

Returns:boolean

true if a complete parse tree will be constructed while parsing, otherwise false

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

Annotations

@NotNull

For debugging and other purposes.

Annotations

@NotNull

Overrides org.antlr.v4.runtime.Recognizer.getErrorListenerDispatch.

Annotations

@Override

Computes the set of input symbols which could follow the current parser state and context, as given by getState and getContext, respectively.

Annotations

@NotNull

See Also

ATN#getExpectedTokens(int, RuleContext)

Annotations

@NotNull

Implements abstract org.antlr.v4.runtime.Recognizer.getInputStream.

Annotations

@Override

Gets the number of syntax errors reported during parsing. This value is incremented each time notifyErrorListeners is called.

See Also

notifyErrorListeners

Overrides org.antlr.v4.runtime.Recognizer.getParseInfo.

Doc from org.antlr.v4.runtime.Recognizer.getParseInfo.

If profiling during the parse/lex, this will return DecisionInfo records for each decision in recognizer in a ParseInfo object.

Annotations

@Override

Annotations

@NotNull

Get the precedence level for the top-most precedence rule.

Returns:int

The precedence level for the top-most precedence rule, or -1 if the parser context is not nested within a precedence rule.

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

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.

Returns:boolean

true if the ParserRuleContext#children list is trimmed using the default Parser.TrimToSizeListener during the parse process.

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:int

the symbol type to check

Returns:boolean

true if symbol can follow the current state in the ATN, otherwise false.

Gets whether a TraceListener is registered as a parse listener for the parser.

See Also

setTrace(boolean)

Match current input symbol against ttype. If the symbol type matches, ANTLRErrorStrategy#reportMatch and consume are called to complete the match process.

If the symbol type does not match, ANTLRErrorStrategy#recoverInline 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 is -1, the symbol is added to the parse tree by calling createErrorNode(ParserRuleContext, Token) then ParserRuleContext#addErrorNode(ErrorNode).

Parameters

ttype:int

the token type to match

Returns:Token

the matched symbol

Annotations

@NotNull

Exceptions

RecognitionException:

if the current input symbol did not match ttype and the error strategy could not recover from the mismatched symbol

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

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

Returns:Token

the matched symbol

Annotations

@NotNull

Exceptions

RecognitionException:

if the current input symbol did not match a wildcard and the error strategy could not recover from the mismatched symbol

Overrides org.antlr.v4.runtime.Recognizer.precpred.

Annotations

@Override

Like enterRule but for recursive rules. Make the current context the child of the incoming localctx.

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:ParseTreeListener

the listener to remove

See Also

addParseListener

Remove all parse listeners.

See Also

addParseListener

reset the parser's state

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.

Set the token stream and reset the parser.

Since

4.3

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.

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:boolean

true to trim the capacity of the ParserRuleContext#children list to its size after a rule is parsed.