Package org.antlr.v4.runtime.atn

Class ATN

java.lang.Object
org.antlr.v4.runtime.atn.ATN
public class ATN extends Object

  • Field Details

    • INVALID_ALT_NUMBER

      public static final int INVALID_ALT_NUMBER
      See Also:

    • states

      @NotNull public final List<ATNState> states

    • statesSnapshot

      ATNState[] statesSnapshot
      Snapshot of states taken after ATN deserialization. Closure pop-return uses this array (plain load) instead of List.get(int). Invalidated by addState(org.antlr.v4.runtime.atn.ATNState)/removeState(org.antlr.v4.runtime.atn.ATNState); rebuilt by freezeStatesSnapshot().

    • decisionToState

      @NotNull public final List<DecisionState> decisionToState
      Each subrule/rule is a decision point and we must track them so we can go back later and build DFA predictors for them. This includes all the rules, subrules, optional blocks, ()+, ()* etc...

    • ruleToStartState

      public RuleStartState[] ruleToStartState
      Maps from rule index to starting state number.

    • ruleToStopState

      public RuleStopState[] ruleToStopState
      Maps from rule index to stop state number.

    • modeNameToStartState

      @NotNull public final Map<String,TokensStartState> modeNameToStartState

    • grammarType

      public final ATNType grammarType
      The type of the ATN.

    • maxTokenType

      public final int maxTokenType
      The maximum value for any symbol recognized by a transition in the ATN.

    • hasUnicodeSMPTransitions

      private boolean hasUnicodeSMPTransitions

    • ruleToTokenType

      public int[] ruleToTokenType
      For lexer ATNs, this maps the rule index to the resulting token type. For parser ATNs, this maps the rule index to the generated bypass token type if the ATNDeserializationOptions.isGenerateRuleBypassTransitions() deserialization option was specified; otherwise, this is null.

    • lexerActions

      public LexerAction[] lexerActions
      For lexer ATNs, this is an array of LexerAction objects which may be referenced by action transitions in the ATN.

    • modeToStartState

      @NotNull public final List<TokensStartState> modeToStartState

    • contextCache

      private final ConcurrentMap<PredictionContext,PredictionContext> contextCache

    • decisionToDFA

      @NotNull public DFA[] decisionToDFA

    • modeToDFA

      @NotNull public DFA[] modeToDFA

    • ll1Cache

      final ConcurrentIntIntMap ll1Cache
      Package-private primitive LL(1) cache for ParserATNSimulator. Copy-on-write, lock-free reads; never appears in public/protected API.

    • ll1Dense

      short[] ll1Dense
      Dense LL(1) table: decision * ll1Stride + token → alt. Zero is a miss (INVALID_ALT_NUMBER). Package-private; the public LL1Table view still wraps ll1Cache. Hot ParserATNSimulator.adaptivePredict(org.antlr.v4.runtime.TokenStream, int, org.antlr.v4.runtime.ParserRuleContext) reads this array instead of hashing the packed key.

    • ll1Stride

      int ll1Stride
      Column count of ll1Dense (maxTokenType + 1).

    • MAX_PRECEDENCE_LL1

      static final int MAX_PRECEDENCE_LL1
      Highest precedence stored in precedenceLL1. The precedence edge map uses the same closed range 0..200.
      See Also:

    • MAX_PRECEDENCE_LL1_STRIDE

      private static final int MAX_PRECEDENCE_LL1_STRIDE
      Skip precedence tables wider than this many token types. 201 rows times this stride is about 1.6MB of shorts; real Java and Groovy vocabularies sit far under it.
      See Also:

    • precedenceLL1

      volatile short[][] precedenceLL1
      Per-decision precedence LL(1) answers. For decision d, precedenceLL1[d][precedence * stride + token] is the alternative, and zero is a miss. stride is table.length / (MAX_PRECEDENCE_LL1 + 1) so a lookup does not re-read ll1Stride.

      Filled only when a precedence decision accepts without consuming input and without semantic context, which is the steady state of left-recursive expression loops (the operator-or-stop decision). Shared by every parser that uses this ATN, including parallel file-granularity parses. Element stores are plain shorts (atomic on the JVM); a racing reader may still observe zero and take the DFA. Cleared by clearDFA().

    • precedenceLL1Lock

      private final Object precedenceLL1Lock
      Publish guard for precedenceLL1. Lookups do not take it.

    • LL1Table

      protected final ConcurrentMap<Integer,Integer> LL1Table
      LL(1) prediction cache exposed as a JDK ConcurrentMap so subclasses and tests keep a stable protected surface. Backed by ll1Cache (single store): external boxed access pays boxing only when this map is used; the hot path never touches Integer.

      The view honors core Map/ConcurrentMap contracts (entrySet/keySet/ values stay consistent with size; putIfAbsent/replace/remove are atomic with respect to other writers). Iterators are weakly consistent snapshots of the published COW table.

  • Constructor Details

    • ATN

      public ATN(@NotNull ATNType grammarType, int maxTokenType)
      Used for runtime deserialization of ATNs from strings

  • Method Details

    • clearDFA

      public final void clearDFA()
      Clears every decision/mode DFA and the LL(1) / context caches.

      When the DFA arrays already match the decision/mode counts, existing DFA instances are cleared in place via DFA.clear() to avoid allocating a new DFA object per decision on every flush. Arrays are only reallocated when their length is stale (for example after ATN structural changes during deserialization).

    • cachedPrecedenceAlt

      final int cachedPrecedenceAlt(int decision, int precedence, int token)
      Precedence LL(1) answer learned for (decision, precedence, token), or INVALID_ALT_NUMBER on a miss.

    • cachePrecedenceAlt

      final void cachePrecedenceAlt(int decision, int precedence, int token, int alt)
      Record a precedence LL(1) answer. No-op for out-of-range keys, a non-positive alternative, or a stride this table will not hold. The first alternative stored for a pair sticks.

    • freezeStatesSnapshot

      final void freezeStatesSnapshot()
      Rebuilds statesSnapshot from states. Called after ATN deserialization so prediction can index states without List.get(int).

    • getCachedState

      final ATNState getCachedState(int stateNumber)
      State at stateNumber, preferring the frozen snapshot.
      Parameters:
      stateNumber - ATN state number
      Returns:
      the state, or null if the slot is empty

    • syncLl1Dense

      final void syncLl1Dense(int packedKey, int alt)
      Mirror a packed (decision, token) entry into ll1Dense. Used when subclasses/tests write LL1Table. No-op before the dense table is allocated.

    • ensureLl1Dense

      final void ensureLl1Dense(int decisionCount)

    • getContextCacheSize

      public int getContextCacheSize()

    • getCachedContext

      public PredictionContext getCachedContext(PredictionContext context)

    • getDecisionToDFA

      public final DFA[] getDecisionToDFA()

    • nextTokens

      @NotNull public IntervalSet nextTokens(ATNState s, @NotNull PredictionContext ctx)
      Compute the set of valid tokens that can occur starting in state s. If ctx is PredictionContext.EMPTY_LOCAL, the set of tokens will not include what can follow the rule surrounding s. In other words, the set will be restricted to tokens reachable staying within s's rule.

    • nextTokens

      @NotNull public IntervalSet nextTokens(@NotNull ATNState s)
      Compute the set of valid tokens that can occur starting in s and staying in same rule. Token.EPSILON is in set if we reach end of rule.

    • addState

      public void addState(@Nullable ATNState state)

    • removeState

      public void removeState(@NotNull ATNState state)

    • defineMode

      public void defineMode(@NotNull String name, @NotNull TokensStartState s)

    • defineDecisionState

      public int defineDecisionState(@NotNull DecisionState s)

    • getDecisionState

      public DecisionState getDecisionState(int decision)

    • getNumberOfDecisions

      public int getNumberOfDecisions()

    • getExpectedTokens

      @NotNull public IntervalSet getExpectedTokens(int stateNumber, @Nullable RuleContext context)
      Computes the set of input symbols which could follow ATN state number stateNumber in the specified full context. This method considers the complete parser context, but does not evaluate semantic predicates (i.e. all predicates encountered during the calculation are assumed true). If a path in the ATN exists from the starting state to the RuleStopState of the outermost context without matching any symbols, Token.EOF is added to the returned set.

      If context is null, it is treated as ParserRuleContext.EMPTY.

      Note that this does NOT give you the set of all tokens that could appear at a given token position in the input phrase. In other words, it does not answer:

      "Given a specific partial input phrase, return the set of all tokens that can follow the last token in the input phrase."

      The big difference is that with just the input, the parser could land right in the middle of a lookahead decision. Getting all possible tokens given a partial input stream is a separate computation. See https://github.com/antlr/antlr4/issues/1428

      For this function, we are specifying an ATN state and call stack to compute what token(s) can come next and specifically: outside of a lookahead decision. That is what you want for error reporting and recovery upon parse error.

      Parameters:
      stateNumber - the ATN state number
      context - the full parse context
      Returns:
      The set of potentially valid input symbols which could follow the specified state in the specified context.
      Throws:
      IllegalArgumentException - if the ATN does not contain a state with number stateNumber

    • hasUnicodeSMPTransitions

      public boolean hasUnicodeSMPTransitions()

    • setHasUnicodeSMPTransitions

      public void setHasUnicodeSMPTransitions(boolean value)