kubernetes/vendor/github.com/antlr4-go/antlr/v4/lexer_atn_simulator.go

var LexerATNSimulatorMinDFAEdge

var LexerATNSimulatorMaxDFAEdge

var LexerATNSimulatorMatchCalls

type ILexerATNSimulator

type LexerATNSimulator

func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *LexerATNSimulator {}

func (l *LexerATNSimulator) copyState(simulator *LexerATNSimulator) {}

func (l *LexerATNSimulator) Match(input CharStream, mode int) int {}

func (l *LexerATNSimulator) reset() {}

func (l *LexerATNSimulator) MatchATN(input CharStream) int {}

func (l *LexerATNSimulator) execATN(input CharStream, ds0 *DFAState) int {}

// 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,
// l method returns {@code nil}.
//
// @param s The current DFA state
// @param t The next input symbol
// @return The existing target DFA state for the given input symbol
// {@code t}, or {@code nil} if the target state for l edge is not
// already cached
func (l *LexerATNSimulator) getExistingTargetState(s *DFAState, t int) *DFAState {}

// computeTargetState computes a target state for an edge in the [DFA], and attempt to add the
// computed state and corresponding edge to the [DFA].
//
// The func returns the computed target [DFA] state for the given input symbol t.
// If this does not lead to a valid [DFA] state, this method
// returns ATNSimulatorError.
func (l *LexerATNSimulator) computeTargetState(input CharStream, s *DFAState, t int) *DFAState {}

func (l *LexerATNSimulator) failOrAccept(prevAccept *SimState, input CharStream, reach *ATNConfigSet, t int) int {}

// getReachableConfigSet when given a starting configuration set, figures out all [ATN] configurations
// we can reach upon input t.
//
// Parameter reach is a return parameter.
func (l *LexerATNSimulator) getReachableConfigSet(input CharStream, closure *ATNConfigSet, reach *ATNConfigSet, t int) {}

func (l *LexerATNSimulator) accept(input CharStream, lexerActionExecutor *LexerActionExecutor, startIndex, index, line, charPos int) {}

func (l *LexerATNSimulator) getReachableTarget(trans Transition, t int) ATNState {}

func (l *LexerATNSimulator) computeStartState(input CharStream, p ATNState) *ATNConfigSet {}

// closure 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 runtimeConfig, all other (potentially reachable) states for
// this rule would have a lower priority.
//
// The func returns true if an accept state is reached.
func (l *LexerATNSimulator) closure(input CharStream, config *ATNConfig, configs *ATNConfigSet,
	currentAltReachedAcceptState, speculative, treatEOFAsEpsilon bool) bool {}

// side-effect: can alter configs.hasSemanticContext
func (l *LexerATNSimulator) getEpsilonTarget(input CharStream, config *ATNConfig, trans Transition,
	configs *ATNConfigSet, speculative, treatEOFAsEpsilon bool) *ATNConfig {}

// evaluatePredicate eEvaluates a predicate specified in the lexer.
//
// If speculative is true, this method was called before
// [consume] for the Matched character. This method should call
// [consume] before evaluating the predicate to ensure position
// sensitive values, including [GetText], [GetLine],
// and [GetColumn], 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].
//
// The func returns true if the specified predicate evaluates to true.
func (l *LexerATNSimulator) evaluatePredicate(input CharStream, ruleIndex, predIndex int, speculative bool) bool {}

func (l *LexerATNSimulator) captureSimState(settings *SimState, input CharStream, dfaState *DFAState) {}

func (l *LexerATNSimulator) addDFAEdge(from *DFAState, tk int, to *DFAState, cfgs *ATNConfigSet) *DFAState {}

// Add a NewDFA state if there isn't one with l 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.
func (l *LexerATNSimulator) addDFAState(configs *ATNConfigSet, suppressEdge bool) *DFAState {}

func (l *LexerATNSimulator) getDFA(mode int) *DFA {}

// GetText returns the text [Match]ed so far for the current token.
func (l *LexerATNSimulator) GetText(input CharStream) string {}

func (l *LexerATNSimulator) Consume(input CharStream) {}

func (l *LexerATNSimulator) GetCharPositionInLine() int {}

func (l *LexerATNSimulator) GetLine() int {}

func (l *LexerATNSimulator) GetTokenName(tt int) string {}

func resetSimState(sim *SimState) {}

type SimState

func NewSimState() *SimState {}

func (s *SimState) reset() {}