Class LexerATNSimulator

java.lang.Object
org.graalvm.shadowed.org.antlr.v4.runtime.atn.ATNSimulator
org.graalvm.shadowed.org.antlr.v4.runtime.atn.LexerATNSimulator
public class LexerATNSimulator extends ATNSimulator
"dup" of ParserInterpreter

  • Field Details

    • debug

      public static final boolean debug
      See Also:

    • dfa_debug

      public static final boolean dfa_debug
      See Also:

    • MIN_DFA_EDGE

      public static final int MIN_DFA_EDGE
      See Also:

    • MAX_DFA_EDGE

      public static final int MAX_DFA_EDGE
      See Also:

    • recog

      protected final Lexer recog

    • startIndex

      protected int startIndex
      The current token's starting index into the character stream. Shared across DFA to ATN simulation in case the ATN fails and the DFA did not have a previous accept state. In this case, we use the ATN-generated exception object.

    • line

      protected int line
      line number 1..n within the input

    • charPositionInLine

      protected int charPositionInLine
      The index of the character relative to the beginning of the line 0..n-1

    • decisionToDFA

      public final DFA[] decisionToDFA

    • mode

      protected int mode

    • prevAccept

      protected final LexerATNSimulator.SimState prevAccept
      Used during DFA/ATN exec to record the most recent accept configuration info

  • Constructor Details

  • Method Details

    • copyState

      public void copyState(LexerATNSimulator simulator)

    • match

      public int match(CharStream input, int mode)

    • reset

      public void reset()
      Specified by:
      reset in class ATNSimulator

    • clearDFA

      public void clearDFA()
      Description copied from class: ATNSimulator
      Clear the DFA cache used by the current instance. Since the DFA cache may be shared by multiple ATN simulators, this method may affect the performance (but not accuracy) of other parsers which are being used concurrently.
      Overrides:
      clearDFA in class ATNSimulator

    • matchATN

      protected int matchATN(CharStream input)

    • execATN

      protected int execATN(CharStream input, DFAState ds0)

    • getExistingTargetState

      protected DFAState getExistingTargetState(DFAState s, int t)
      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.
      Parameters:
      s - 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(CharStream input, DFAState s, 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.
      Parameters:
      input - The input stream
      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.

    • failOrAccept

      protected int failOrAccept(LexerATNSimulator.SimState prevAccept, CharStream input, ATNConfigSet reach, int t)

    • getReachableConfigSet

      protected void getReachableConfigSet(CharStream input, ATNConfigSet closure, ATNConfigSet reach, int t)
      Given a starting configuration set, figure out all ATN configurations we can reach upon input t. Parameter reach is a return parameter.

    • accept

      protected void accept(CharStream input, LexerActionExecutor lexerActionExecutor, int startIndex, int index, int line, int charPos)

    • getReachableTarget

      protected ATNState getReachableTarget(Transition trans, int t)

    • computeStartState

      protected ATNConfigSet computeStartState(CharStream input, ATNState p)

    • closure

      protected boolean closure(CharStream input, LexerATNConfig config, ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative, boolean treatEofAsEpsilon)
      Since the alternatives within any lexer decision are ordered by preference, this method stops pursuing the closure as soon as an accept state is reached. After the first accept state is reached by depth-first search from config, all other (potentially reachable) states for this rule would have a lower priority.
      Returns:
      true if an accept state is reached, otherwise false.

    • getEpsilonTarget

      protected LexerATNConfig getEpsilonTarget(CharStream input, LexerATNConfig config, Transition t, ATNConfigSet configs, boolean speculative, boolean treatEofAsEpsilon)

    • evaluatePredicate

      protected boolean evaluatePredicate(CharStream input, int ruleIndex, int predIndex, boolean speculative)
      Evaluate a predicate specified in the lexer.

      If speculative is true, this method was called before consume(org.graalvm.shadowed.org.antlr.v4.runtime.CharStream) for the matched character. This method should call consume(org.graalvm.shadowed.org.antlr.v4.runtime.CharStream) before evaluating the predicate to ensure position sensitive values, including Lexer.getText(), Lexer.getLine(), and Lexer.getCharPositionInLine(), properly reflect the current lexer state. This method should restore input and the simulator to the original state before returning (i.e. undo the actions made by the call to consume(org.graalvm.shadowed.org.antlr.v4.runtime.CharStream).

      Parameters:
      input - The input stream.
      ruleIndex - The rule containing the predicate.
      predIndex - The index of the predicate within the rule.
      speculative - true if the current index in input is one character before the predicate's location.
      Returns:
      true if the specified predicate evaluates to true.

    • captureSimState

      protected void captureSimState(LexerATNSimulator.SimState settings, CharStream input, DFAState dfaState)

    • addDFAEdge

      protected DFAState addDFAEdge(DFAState from, int t, ATNConfigSet q)

    • addDFAEdge

      protected void addDFAEdge(DFAState p, int t, DFAState q)

    • addDFAState

      protected DFAState addDFAState(ATNConfigSet configs)
      Add a new DFA state if there isn't one with this set of configurations already. This method also detects the first configuration containing an ATN rule stop state. Later, when traversing the DFA, we will know which rule to accept.

    • getDFA

      public final DFA getDFA(int mode)

    • getText

      public String getText(CharStream input)
      Get the text matched so far for the current token.

    • getLine

      public int getLine()

    • setLine

      public void setLine(int line)

    • getCharPositionInLine

      public int getCharPositionInLine()

    • setCharPositionInLine

      public void setCharPositionInLine(int charPositionInLine)

    • consume

      public void consume(CharStream input)

    • getTokenName

      public String getTokenName(int t)