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() { … }
Codebase Browser
kubernetes