org.antlr.v4.runtime.atn

Class ProfilingATNSimulator

java.lang.Object

org.antlr.v4.runtime.atn.ATNSimulator

org.antlr.v4.runtime.atn.ParserATNSimulator

org.antlr.v4.runtime.atn.ProfilingATNSimulator

public class ProfilingATNSimulator
extends ParserATNSimulator

Since:

4.3

Field Summary

Fields

Modifier and Type	Field and Description
protected TokenStream	_input
protected int	_llStopIndex
protected int	_sllStopIndex
protected int	_startIndex
protected int	conflictingAltResolvedBySLL At the point of LL failover, we record how SLL would resolve the conflict so that we can determine whether or not a decision / input pair is context-sensitive.
protected int	currentDecision
protected SimulatorState	currentState
protected DecisionInfo[]	decisions
protected int	numDecisions

Fields inherited from class org.antlr.v4.runtime.atn.ParserATNSimulator

always_try_local_context, debug, dfa_debug, enable_global_context_dfa, force_global_context, optimize_hidden_conflicted_configs, optimize_ll1, optimize_tail_calls, optimize_unique_closure, parser, reportAmbiguities, retry_debug, tail_call_preserves_sll, treat_sllk1_conflict_as_ambiguity, userWantsCtxSensitive

Fields inherited from class org.antlr.v4.runtime.atn.ATNSimulator

atn, ERROR, RULE_LF_VARIANT_MARKER, RULE_NOLF_VARIANT_MARKER, RULE_VARIANT_DELIMITER, SERIALIZED_UUID, SERIALIZED_VERSION

Constructor Summary

Constructors

Constructor and Description
ProfilingATNSimulator(Parser parser)

Method Summary

Modifier and Type	Method and Description
int	adaptivePredict(TokenStream input, int decision, ParserRuleContext outerContext)
protected SimulatorState	computeReachSet(DFA dfa, SimulatorState previous, int t, PredictionContextCache contextCache)
protected SimulatorState	computeStartState(DFA dfa, ParserRuleContext globalContext, boolean useContext)
protected Tuple2<DFAState,ParserRuleContext>	computeTargetState(DFA dfa, DFAState s, ParserRuleContext remainingGlobalContext, int t, boolean useContext, PredictionContextCache contextCache) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
protected boolean	evalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt) Evaluate a semantic context within a specific parser context.
SimulatorState	getCurrentState()
DecisionInfo[]	getDecisionInfo()
protected DFAState	getExistingTargetState(DFAState previousD, int t) Get an existing target state for an edge in the DFA.
protected SimulatorState	getStartState(DFA dfa, TokenStream input, ParserRuleContext outerContext, boolean useContext)
protected void	reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) If context sensitive parsing, we know it's ambiguity not conflict
protected void	reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, SimulatorState conflictState, int startIndex, int stopIndex)
protected void	reportContextSensitivity(DFA dfa, int prediction, SimulatorState acceptState, int startIndex, int stopIndex)

Methods inherited from class org.antlr.v4.runtime.atn.ParserATNSimulator

actionTransition, adaptivePredict, addDFAContextState, addDFAEdge, addDFAEdge, addDFAState, applyPrecedenceFilter, closure, closure, configWithAltAtStopState, createDFAState, dumpDeadEndConfigs, evalSemanticContext, execATN, execDFA, getConflictingAltsFromConfigSet, getEpsilonTarget, getLookaheadName, getParser, getPredicatePredictions, getPredictionMode, getPredsForAmbigAlts, getReachableTarget, getReturnState, getRuleName, getTokenName, getUniqueAlt, handleNoViableAlt, isAcceptState, noViableAlt, precedenceTransition, predicateDFAState, predTransition, removeAllConfigsNotInRuleStopState, reset, ruleTransition, setPredictionMode, skipTailCalls

Methods inherited from class org.antlr.v4.runtime.atn.ATNSimulator

checkCondition, checkCondition, clearDFA, deserialize, edgeFactory, stateFactory, toInt, toInt32, toLong, toUUID

Methods inherited from class java.lang.Object

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

Field Detail

decisions

protected final DecisionInfo[] decisions

numDecisions

protected int numDecisions

_input

protected TokenStream _input

_startIndex

protected int _startIndex

_sllStopIndex

protected int _sllStopIndex

_llStopIndex

protected int _llStopIndex

currentDecision

protected int currentDecision

currentState

protected SimulatorState currentState

conflictingAltResolvedBySLL

protected int conflictingAltResolvedBySLL

At the point of LL failover, we record how SLL would resolve the conflict so that we can determine whether or not a decision / input pair is context-sensitive. If LL gives a different result than SLL's predicted alternative, we have a context sensitivity for sure. The converse is not necessarily true, however. It's possible that after conflict resolution chooses minimum alternatives, SLL could get the same answer as LL. Regardless of whether or not the result indicates an ambiguity, it is not treated as a context sensitivity because LL prediction was not required in order to produce a correct prediction for this decision and input sequence. It may in fact still be a context sensitivity but we don't know by looking at the minimum alternatives for the current input.

Constructor Detail

ProfilingATNSimulator

public ProfilingATNSimulator(Parser parser)

Method Detail

adaptivePredict

public int adaptivePredict(TokenStream input,
                           int decision,
                           ParserRuleContext outerContext)

Overrides:

adaptivePredict in class ParserATNSimulator

getStartState

protected SimulatorState getStartState(DFA dfa,
                                       TokenStream input,
                                       ParserRuleContext outerContext,
                                       boolean useContext)

Overrides:

getStartState in class ParserATNSimulator

computeStartState

protected SimulatorState computeStartState(DFA dfa,
                                           ParserRuleContext globalContext,
                                           boolean useContext)

Overrides:

computeStartState in class ParserATNSimulator

computeReachSet

protected SimulatorState computeReachSet(DFA dfa,
                                         SimulatorState previous,
                                         int t,
                                         PredictionContextCache contextCache)

Overrides:

computeReachSet in class ParserATNSimulator

getExistingTargetState

protected DFAState getExistingTargetState(DFAState previousD,
                                          int t)

Description copied from class: ParserATNSimulator

Get an existing target state for an edge in the DFA. If the target state for the edge has not yet been computed or is otherwise not available, this method returns null.

Overrides:

getExistingTargetState in class ParserATNSimulator

Parameters:

previousD - The current DFA state

t - The next input symbol

Returns:

The existing target DFA state for the given input symbol t, or null if the target state for this edge is not already cached

computeTargetState

protected Tuple2<DFAState,ParserRuleContext> computeTargetState(DFA dfa,
                                                                DFAState s,
                                                                ParserRuleContext remainingGlobalContext,
                                                                int t,
                                                                boolean useContext,
                                                                PredictionContextCache contextCache)

Description copied from class: ParserATNSimulator

Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.

Overrides:

computeTargetState in class ParserATNSimulator

s - The current DFA state

t - The next input symbol

Returns:

The computed target DFA state for the given input symbol t. If t does not lead to a valid DFA state, this method returns ATNSimulator.ERROR.

evalSemanticContext

protected boolean evalSemanticContext(SemanticContext pred,
                                      ParserRuleContext parserCallStack,
                                      int alt)

Description copied from class: ParserATNSimulator

Evaluate a semantic context within a specific parser context.

This method might not be called for every semantic context evaluated during the prediction process. In particular, we currently do not evaluate the following but it may change in the future:

• Precedence predicates (represented by SemanticContext.PrecedencePredicate) are not currently evaluated through this method.
• Operator predicates (represented by SemanticContext.AND and SemanticContext.OR) are evaluated as a single semantic context, rather than evaluating the operands individually. Implementations which require evaluation results from individual predicates should override this method to explicitly handle evaluation of the operands within operator predicates.

Overrides:

evalSemanticContext in class ParserATNSimulator

Parameters:

pred - The semantic context to evaluate

parserCallStack - The parser context in which to evaluate the semantic context

alt - The alternative which is guarded by pred

reportContextSensitivity

protected void reportContextSensitivity(DFA dfa,
                                        int prediction,
                                        SimulatorState acceptState,
                                        int startIndex,
                                        int stopIndex)

Overrides:

reportContextSensitivity in class ParserATNSimulator

reportAttemptingFullContext

protected void reportAttemptingFullContext(DFA dfa,
                                           BitSet conflictingAlts,
                                           SimulatorState conflictState,
                                           int startIndex,
                                           int stopIndex)

Overrides:

reportAttemptingFullContext in class ParserATNSimulator

reportAmbiguity

protected void reportAmbiguity(@NotNull
                               DFA dfa,
                               DFAState D,
                               int startIndex,
                               int stopIndex,
                               boolean exact,
                               @NotNull
                               BitSet ambigAlts,
                               @NotNull
                               ATNConfigSet configs)

Description copied from class: ParserATNSimulator

If context sensitive parsing, we know it's ambiguity not conflict

Overrides:

reportAmbiguity in class ParserATNSimulator

getDecisionInfo

public DecisionInfo[] getDecisionInfo()

getCurrentState

public SimulatorState getCurrentState()