org.antlr.v4.runtime

Class DiagnosticErrorListener

java.lang.Object

org.antlr.v4.runtime.BaseErrorListener

org.antlr.v4.runtime.DiagnosticErrorListener

All Implemented Interfaces:

ANTLRErrorListener<Token>, ParserErrorListener

public class DiagnosticErrorListener
extends BaseErrorListener

This implementation of ANTLRErrorListener can be used to identify certain potential correctness and performance problems in grammars. "Reports" are made by calling Parser.notifyErrorListeners(java.lang.String) with the appropriate message.

• Ambiguities: These are cases where more than one path through the grammar can match the input.
• Weak context sensitivity: These are cases where full-context prediction resolved an SLL conflict to a unique alternative which equaled the minimum alternative of the SLL conflict.
• Strong (forced) context sensitivity: These are cases where the full-context prediction resolved an SLL conflict to a unique alternative, and the minimum alternative of the SLL conflict was found to not be a truly viable alternative. Two-stage parsing cannot be used for inputs where this situation occurs.

Author:

Sam Harwell

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	exactOnly When true, only exactly known ambiguities are reported.

Constructor Summary

Constructors

Constructor and Description
DiagnosticErrorListener() Initializes a new instance of DiagnosticErrorListener which only reports exact ambiguities.
DiagnosticErrorListener(boolean exactOnly) Initializes a new instance of DiagnosticErrorListener, specifying whether all ambiguities or only exact ambiguities are reported.

Method Summary

Modifier and Type	Method and Description
protected BitSet	getConflictingAlts(BitSet reportedAlts, ATNConfigSet configs) Computes the set of conflicting or ambiguous alternatives from a configuration set, if that information was not already provided by the parser.
protected <T extends Token> String	getDecisionDescription(Parser recognizer, DFA dfa)
void	reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) This method is called by the parser when a full-context prediction results in an ambiguity.
void	reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, SimulatorState conflictState) This method is called when an SLL conflict occurs and the parser is about to use the full context information to make an LL decision.
void	reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, SimulatorState acceptState) This method is called by the parser when a full-context prediction has a unique result.

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

syntaxError

Methods inherited from class java.lang.Object

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

Field Detail

exactOnly

protected final boolean exactOnly

When true, only exactly known ambiguities are reported.

Constructor Detail

DiagnosticErrorListener

public DiagnosticErrorListener()

Initializes a new instance of DiagnosticErrorListener which only reports exact ambiguities.

DiagnosticErrorListener

public DiagnosticErrorListener(boolean exactOnly)

Initializes a new instance of DiagnosticErrorListener, specifying whether all ambiguities or only exact ambiguities are reported.

Parameters:

exactOnly - true to report only exact ambiguities, otherwise false to report all ambiguities.

Method Detail

reportAmbiguity

public void reportAmbiguity(@NotNull
                            Parser recognizer,
                            @NotNull
                            DFA dfa,
                            int startIndex,
                            int stopIndex,
                            boolean exact,
                            @Nullable
                            BitSet ambigAlts,
                            @NotNull
                            ATNConfigSet configs)

Description copied from interface: ParserErrorListener

This method is called by the parser when a full-context prediction results in an ambiguity.

Each full-context prediction which does not result in a syntax error will call either ParserErrorListener.reportContextSensitivity(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.dfa.DFA, int, int, int, org.antlr.v4.runtime.atn.SimulatorState) or ParserErrorListener.reportAmbiguity(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.dfa.DFA, int, int, boolean, java.util.BitSet, org.antlr.v4.runtime.atn.ATNConfigSet).

When ambigAlts is not null, it contains the set of potentially viable alternatives identified by the prediction algorithm. When ambigAlts is null, use ATNConfigSet.getRepresentedAlternatives() to obtain the represented alternatives from the configs argument.

When exact is true, all of the potentially viable alternatives are truly viable, i.e. this is reporting an exact ambiguity. When exact is false, at least two of the potentially viable alternatives are viable for the current input, but the prediction algorithm terminated as soon as it determined that at least the minimum potentially viable alternative is truly viable.

When the PredictionMode.LL_EXACT_AMBIG_DETECTION prediction mode is used, the parser is required to identify exact ambiguities so exact will always be true.

Specified by:

reportAmbiguity in interface ParserErrorListener

Overrides:

reportAmbiguity in class BaseErrorListener

Parameters:

recognizer - the parser instance

dfa - the DFA for the current decision

startIndex - the input index where the decision started

stopIndex - the input input where the ambiguity was identified

exact - true if the ambiguity is exactly known, otherwise false. This is always true when PredictionMode.LL_EXACT_AMBIG_DETECTION is used.

ambigAlts - the potentially ambiguous alternatives, or null to indicate that the potentially ambiguous alternatives are the complete set of represented alternatives in configs

configs - the ATN configuration set where the ambiguity was identified

reportAttemptingFullContext

public void reportAttemptingFullContext(@NotNull
                                        Parser recognizer,
                                        @NotNull
                                        DFA dfa,
                                        int startIndex,
                                        int stopIndex,
                                        @Nullable
                                        BitSet conflictingAlts,
                                        @NotNull
                                        SimulatorState conflictState)

Description copied from interface: ParserErrorListener

This method is called when an SLL conflict occurs and the parser is about to use the full context information to make an LL decision.

If one or more configurations in configs contains a semantic predicate, the predicates are evaluated before this method is called. The subset of alternatives which are still viable after predicates are evaluated is reported in conflictingAlts.

Specified by:

reportAttemptingFullContext in interface ParserErrorListener

Overrides:

reportAttemptingFullContext in class BaseErrorListener

Parameters:

recognizer - the parser instance

dfa - the DFA for the current decision

startIndex - the input index where the decision started

stopIndex - the input index where the SLL conflict occurred

conflictingAlts - The specific conflicting alternatives. If this is null, the conflicting alternatives are all alternatives represented in configs.

conflictState - the simulator state when the SLL conflict was detected

reportContextSensitivity

public void reportContextSensitivity(@NotNull
                                     Parser recognizer,
                                     @NotNull
                                     DFA dfa,
                                     int startIndex,
                                     int stopIndex,
                                     int prediction,
                                     @NotNull
                                     SimulatorState acceptState)

Description copied from interface: ParserErrorListener

This method is called by the parser when a full-context prediction has a unique result.

Each full-context prediction which does not result in a syntax error will call either ParserErrorListener.reportContextSensitivity(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.dfa.DFA, int, int, int, org.antlr.v4.runtime.atn.SimulatorState) or ParserErrorListener.reportAmbiguity(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.dfa.DFA, int, int, boolean, java.util.BitSet, org.antlr.v4.runtime.atn.ATNConfigSet).

For prediction implementations that only evaluate full-context predictions when an SLL conflict is found (including the default ParserATNSimulator implementation), this method reports cases where SLL conflicts were resolved to unique full-context predictions, i.e. the decision was context-sensitive. This report does not necessarily indicate a problem, and it may appear even in completely unambiguous grammars.

configs may have more than one represented alternative if the full-context prediction algorithm does not evaluate predicates before beginning the full-context prediction. In all cases, the final prediction is passed as the prediction argument.

Note that the definition of "context sensitivity" in this method differs from the concept in DecisionInfo.contextSensitivities. This method reports all instances where an SLL conflict occurred but LL parsing produced a unique result, whether or not that unique result matches the minimum alternative in the SLL conflicting set.

Specified by:

reportContextSensitivity in interface ParserErrorListener

Overrides:

reportContextSensitivity in class BaseErrorListener

Parameters:

recognizer - the parser instance

dfa - the DFA for the current decision

startIndex - the input index where the decision started

stopIndex - the input index where the context sensitivity was finally determined

prediction - the unambiguous result of the full-context prediction

acceptState - the simulator state when the unambiguous prediction was determined

getDecisionDescription

protected <T extends Token> String getDecisionDescription(@NotNull
                                                          Parser recognizer,
                                                          @NotNull
                                                          DFA dfa)

getConflictingAlts

@NotNull
protected BitSet getConflictingAlts(@Nullable
                                              BitSet reportedAlts,
                                              @NotNull
                                              ATNConfigSet configs)

Computes the set of conflicting or ambiguous alternatives from a configuration set, if that information was not already provided by the parser.

Parameters:

reportedAlts - The set of conflicting or ambiguous alternatives, as reported by the parser.

configs - The conflicting or ambiguous configuration set.

Returns:

Returns reportedAlts if it is not null, otherwise returns the set of alternatives represented in configs.