Derive a new parser from an old one that has knowledge of the grammar. The Grammar object is used to correctly compute outer alternative numbers for parse tree nodes. A parser of the same type is created for subclasses of ParserInterpreter.

identify the ATN states where we need to set the outer alt number. For regular rules, that's the block at the target to rule start state. For left-recursive rules, we track the primary block, which looks just like a regular rule's outer block, and the star loop block (always there even if 1 alt).

Given an ambiguous parse information, return the list of ambiguous parse trees. An ambiguity occurs when a specific token sequence can be recognized in more than one way by the grammar. These ambiguities are detected only at decision points. The list of trees includes the actual interpretation (that for the minimum alternative number) and all ambiguous alternatives. The actual interpretation is always first. This method reuses the same physical input token stream used to detect the ambiguity by the original parser in the first place. This method resets/seeks within but does not alter originalParser. The trees are rooted at the node whose start..stop token indices include the start and stop indices of this ambiguity event. That is, the trees returned will always include the complete ambiguous subphrase identified by the ambiguity event. The subtrees returned will also always contain the node associated with the overridden decision. Be aware that this method does NOT notify error or parse listeners as it would trigger duplicate or otherwise unwanted events. This uses a temporary ParserATNSimulator and a ParserInterpreter so we don't mess up any statistics, event lists, etc... The parse tree constructed while identifying/making ambiguityInfo is not affected by this method as it creates a new parser interp to get the ambiguous interpretations. Nodes in the returned ambig trees are independent of the original parse tree (constructed while identifying/creating ambiguityInfo).

Parameters

g:Grammar

From which grammar should we drive alternative numbers and alternative labels.

originalParser:Parser

The parser used to create ambiguityInfo; it is not modified by this routine and can be either a generated or interpreted parser. It's token stream *is* reset/seek()'d.

tokens:TokenStream

A stream of tokens to use with the temporary parser. This will often be just the token stream within the original parser but here it is for flexibility.

decision:int

Which decision to try different alternatives for.

alts:BitSet

The set of alternatives to try while re-parsing.

startIndex:int

The index of the first token of the ambiguous input or other input of interest.

stopIndex:int

The index of the last token of the ambiguous input. The start and stop indexes are used primarily to identify how much of the resulting parse tree to return.

startRuleIndex:int

The start rule for the entire grammar, not the ambiguous decision. We re-parse the entire input and so we need the original start rule.

Returns:List<ParserRuleContext>

The list of all possible interpretations of the input for the decision in ambiguityInfo. The actual interpretation chosen by the parser is always given first because this method retests the input in alternative order and ANTLR always resolves ambiguities by choosing the first alternative that matches the input. The subtree returned

Exceptions

RecognitionException:

Throws upon syntax error while matching ambig input.

Since

4.5.1

Return a list of parse trees, one for each alternative in a decision given the same input. Very similar to getAllPossibleParseTrees except that it re-parses the input for every alternative in a decision, not just the ambiguous ones (there is no alts parameter here). This method also tries to reduce the size of the parse trees by stripping away children of the tree that are completely out of range of startIndex..stopIndex. Also, because errors are expected, we use a specialized error handler that more or less bails out but that also consumes the first erroneous token at least. This ensures that an error node will be in the parse tree for display.

Since

4.5.1

Overrides org.antlr.v4.runtime.ParserInterpreter.reset.

Doc from org.antlr.v4.runtime.Parser.reset.

reset the parser's state

Annotations

@Override