Package 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	Description
protected int	_llStopIndex
protected int	_sllStopIndex
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 DFAState	currentState
protected DecisionInfo[]	decisions
protected int	numDecisions

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

_dfa, _input, _outerContext, _startIndex, debug, debug_list_atn_decisions, decisionToDFA, dfa_debug, mergeCache, parser, retry_debug, TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT

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

atn, ERROR, sharedContextCache

Constructor Summary

Constructors

Constructor	Description
ProfilingATNSimulator(Parser parser)

Method Summary

Modifier and Type	Method	Description
int	adaptivePredict(TokenStream input, int decision, ParserRuleContext outerContext)
protected ATNConfigSet	computeReachSet(ATNConfigSet closure, int t, boolean fullCtx)
protected DFAState	computeTargetState(DFA dfa, DFAState previousD, int t)	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, boolean fullCtx)	Evaluate a semantic context within a specific parser context.
DFAState	getCurrentState()
DecisionInfo[]	getDecisionInfo()
protected DFAState	getExistingTargetState(DFAState previousD, int t)	Get an existing target state for an edge in the DFA.
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, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex)

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

actionTransition, addDFAEdge, addDFAState, applyPrecedenceFilter, canDropLoopEntryEdgeInLeftRecursiveRule, clearDFA, closure, closure_, closureCheckingStopState, computeStartState, dumpDeadEndConfigs, evalSemanticContext, execATN, execATNWithFullContext, getAltThatFinishedDecisionEntryRule, getConflictingAlts, getConflictingAltsOrUniqueAlt, getEpsilonTarget, getLookaheadName, getParser, getPredicatePredictions, getPredictionMode, getPredsForAmbigAlts, getReachableTarget, getRuleName, getSafeEnv, getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule, getTokenName, getUniqueAlt, noViableAlt, precedenceTransition, predicateDFAState, predTransition, removeAllConfigsNotInRuleStopState, reset, ruleTransition, setPredictionMode, splitAccordingToSemanticValidity

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

getCachedContext, getSharedContextCache

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

_sllStopIndex

protected int _sllStopIndex

_llStopIndex

protected int _llStopIndex

currentDecision

protected int currentDecision

currentState

protected DFAState 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

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 DFAState computeTargetState(DFA dfa,
                                      DFAState previousD,
                                      int t)

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

Parameters:

dfa - The DFA

previousD - 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.

computeReachSet

protected ATNConfigSet computeReachSet(ATNConfigSet closure,
                                       int t,
                                       boolean fullCtx)

Overrides:

computeReachSet in class ParserATNSimulator

evalSemanticContext

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

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

fullCtx - true if the evaluation is occurring during LL prediction; otherwise, false if the evaluation is occurring during SLL prediction

reportAttemptingFullContext

protected void reportAttemptingFullContext(DFA dfa,
                                           BitSet conflictingAlts,
                                           ATNConfigSet configs,
                                           int startIndex,
                                           int stopIndex)

Overrides:

reportAttemptingFullContext in class ParserATNSimulator

reportContextSensitivity

protected void reportContextSensitivity(DFA dfa,
                                        int prediction,
                                        ATNConfigSet configs,
                                        int startIndex,
                                        int stopIndex)

Overrides:

reportContextSensitivity in class ParserATNSimulator

reportAmbiguity

protected void reportAmbiguity(DFA dfa,
                               DFAState D,
                               int startIndex,
                               int stopIndex,
                               boolean exact,
                               BitSet ambigAlts,
                               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 DFAState getCurrentState()