antlr

package module

Go to main page

Versions in this module

v4

v4.13.1

May 15, 2024

Changes in this version

type BaseToken

+ func (b *BaseToken) GetText() string

+ func (b *BaseToken) SetText(text string)

+ func (b *BaseToken) String() string

+ type Mutex struct

+ func (m *Mutex) Lock()

+ func (m *Mutex) Unlock()

+ type RWMutex struct

+ func (m *RWMutex) Lock()

+ func (m *RWMutex) RLock()

+ func (m *RWMutex) RUnlock()

+ func (m *RWMutex) Unlock()

v4.13.0

May 19, 2023

Changes in this version

+ const DefaultProgramName

+ const MinTokenIndex

+ const PredictionContextArray

+ const PredictionContextEmpty

+ const PredictionContextSingleton

+ const ProgramInitSize

+ var CollectionDescriptors = map[CollectionSource]CollectionDescriptor

+ var Statistics = &goRunStats

+ func ConfigureRuntime(options ...runtimeOption) error

+ func InitBaseParserRuleContext(prc *BaseParserRuleContext, parent ParserRuleContext, invokingStateNumber int)

+ func WithLRLoopEntryBranchOpt(off bool) runtimeOption

+ func WithLexerATNSimulatorDFADebug(debug bool) runtimeOption

+ func WithLexerATNSimulatorDebug(debug bool) runtimeOption

+ func WithMemoryManager(use bool) runtimeOption

+ func WithParserATNSimulatorDFADebug(debug bool) runtimeOption

+ func WithParserATNSimulatorDebug(debug bool) runtimeOption

+ func WithParserATNSimulatorRetryDebug(debug bool) runtimeOption

+ func WithParserATNSimulatorTraceATNSim(trace bool) runtimeOption

+ func WithStatsTraceStacks(trace bool) runtimeOption

+ func WithTopN(topN int) statsOption

type ATNConfig

+ func NewATNConfig(c *ATNConfig, state ATNState, context *PredictionContext, ...) *ATNConfig

+ func NewATNConfig1(c *ATNConfig, state ATNState, context *PredictionContext) *ATNConfig

+ func NewATNConfig2(c *ATNConfig, semanticContext SemanticContext) *ATNConfig

+ func NewATNConfig3(c *ATNConfig, state ATNState, semanticContext SemanticContext) *ATNConfig

+ func NewATNConfig4(c *ATNConfig, state ATNState) *ATNConfig

+ func NewATNConfig5(state ATNState, alt int, context *PredictionContext, ...) *ATNConfig

+ func NewATNConfig6(state ATNState, alt int, context *PredictionContext) *ATNConfig

+ func (a *ATNConfig) InitATNConfig(c *ATNConfig, state ATNState, alt int, context *PredictionContext, ...)

+ func (a *ATNConfig) LEquals(other Collectable[*ATNConfig]) bool

+ func (a *ATNConfig) LHash() int

+ func (a *ATNConfig) PEquals(o Collectable[*ATNConfig]) bool

+ func (a *ATNConfig) PHash() int

type ATNConfigSet

+ func NewATNConfigSet(fullCtx bool) *ATNConfigSet

+ func (b *ATNConfigSet) Compare(bs *ATNConfigSet) bool

type BaseATNState

+ func NewATNState() *BaseATNState

type BaseLexer

+ func (b *BaseLexer) Reset()

type BaseParserRuleContext

+ RuleIndex int

+ func (prc *BaseParserRuleContext) GetAltNumber() int

+ func (prc *BaseParserRuleContext) GetInvokingState() int

+ func (prc *BaseParserRuleContext) GetParent() Tree

+ func (prc *BaseParserRuleContext) GetRuleIndex() int

+ func (prc *BaseParserRuleContext) IsEmpty() bool

+ func (prc *BaseParserRuleContext) SetAltNumber(_ int)

+ func (prc *BaseParserRuleContext) SetInvokingState(t int)

+ func (prc *BaseParserRuleContext) SetParent(v Tree)

type BaseRecognizer

+ SynErr RecognitionException

+ func (b *BaseRecognizer) GetError() RecognitionException

+ func (b *BaseRecognizer) HasError() bool

+ func (b *BaseRecognizer) SetError(err RecognitionException)

+ type ClosureBusy struct

+ func NewClosureBusy(desc string) *ClosureBusy

+ func (c *ClosureBusy) Put(config *ATNConfig) (*ATNConfig, bool)

+ type CollectionDescriptor struct

+ Description string

+ SybolicName string

+ type CollectionSource int

+ const ATNConfigCollection

+ const ATNConfigLookupCollection

+ const ATNStateCollection

+ const AltSetCollection

+ const ClosureBusyCollection

+ const DFAStateCollection

+ const MergeCacheCollection

+ const PredictionContextCacheCollection

+ const PredictionContextCollection

+ const PredictionVisitedCollection

+ const ReachSetCollection

+ const SemanticContextCollection

+ const UnknownCollection

type CommonTokenStream

+ func (c *CommonTokenStream) Reset()

type DFA

+ func (d *DFA) Get(s *DFAState) (*DFAState, bool)

+ func (d *DFA) Len() int

+ func (d *DFA) Put(s *DFAState) (*DFAState, bool)

type DefaultErrorStrategy

+ func (d *DefaultErrorStrategy) GetErrorRecoverySet(recognizer Parser) *IntervalSet

type InputStream

+ func NewIoStream(reader io.Reader) *InputStream

type Interval

+ func (i Interval) Length() int

type IntervalSet

+ func (i *IntervalSet) Equals(other *IntervalSet) bool

+ type IterativeParseTreeWalker struct

+ func NewIterativeParseTreeWalker() *IterativeParseTreeWalker

+ func (i *IterativeParseTreeWalker) Walk(listener ParseTreeListener, t Tree)

+ type JPCEntry struct

+ type JPCMap struct

+ func NewJPCMap(cType CollectionSource, desc string) *JPCMap

+ func (pcm *JPCMap) Get(k1, k2 *PredictionContext) (*PredictionContext, bool)

+ func (pcm *JPCMap) Put(k1, k2, v *PredictionContext)

+ type JPCMap2 struct

+ func NewJPCMap2(cType CollectionSource, desc string) *JPCMap2

+ func (pcm *JPCMap2) Get(k1, k2 *PredictionContext) (*PredictionContext, bool)

+ func (pcm *JPCMap2) Put(k1, k2, v *PredictionContext) (*PredictionContext, bool)

+ type JStatRec struct

+ CreateStack []byte

+ CurSize int

+ Description string

+ GetHashConflicts int

+ GetHits int

+ GetMisses int

+ GetNoEnt int

+ Gets int

+ MaxSize int

+ MaxSlotSize int

+ PutHashConflicts int

+ PutHits int

+ PutMisses int

+ Puts int

+ Source CollectionSource

type LexerSkipAction

+ func (b *LexerSkipAction) Equals(other LexerAction) bool

type ParseCancellationException

+ func (p ParseCancellationException) GetInputStream() IntStream

+ func (p ParseCancellationException) GetMessage() string

+ func (p ParseCancellationException) GetOffendingToken() Token

type PredictionContext

+ func (p *PredictionContext) ArrayEquals(o Collectable[*PredictionContext]) bool

+ func (p *PredictionContext) GetReturnStates() []int

+ func (p *PredictionContext) SingletonEquals(other Collectable[*PredictionContext]) bool

+ func (p *PredictionContext) Type() int

type Recognizer

+ GetError func() RecognitionException

+ HasError func() bool

+ SetError func(RecognitionException)

type Token

+ String func() string

type TokenStream

+ Reset func()

+ type VisitEntry struct

+ type VisitList struct

+ type VisitRecord struct

+ func NewVisitRecord() *VisitRecord

+ func (vr *VisitRecord) Get(k *PredictionContext) (*PredictionContext, bool)

+ func (vr *VisitRecord) Put(k, v *PredictionContext) (*PredictionContext, bool)

+ func (vr *VisitRecord) Release()

v4.12.0

May 18, 2023

Changes in this version

+ const ATNStateBasic

+ const ATNStateBlockEnd

+ const ATNStateBlockStart

+ const ATNStateInvalidStateNumber

+ const ATNStateInvalidType

+ const ATNStateLoopEnd

+ const ATNStatePlusBlockStart

+ const ATNStatePlusLoopBack

+ const ATNStateRuleStart

+ const ATNStateRuleStop

+ const ATNStateStarBlockStart

+ const ATNStateStarLoopBack

+ const ATNStateStarLoopEntry

+ const ATNStateTokenStart

+ const ATNTypeLexer

+ const ATNTypeParser

+ const BasePredictionContextEmptyReturnState

+ const Default_Program_Name

+ const LL1AnalyzerHitPred

+ const LexerActionTypeChannel

+ const LexerActionTypeCustom

+ const LexerActionTypeMode

+ const LexerActionTypeMore

+ const LexerActionTypePopMode

+ const LexerActionTypePushMode

+ const LexerActionTypeSkip

+ const LexerActionTypeType

+ const LexerDefaultMode

+ const LexerDefaultTokenChannel

+ const LexerHidden

+ const LexerMaxCharValue

+ const LexerMinCharValue

+ const LexerMore

+ const LexerSkip

+ const Min_Token_Index

+ const PredictionModeLL

+ const PredictionModeLLExactAmbigDetection

+ const PredictionModeSLL

+ const Program_Init_Size

+ const TokenDefaultChannel

+ const TokenEOF

+ const TokenEpsilon

+ const TokenHiddenChannel

+ const TokenInvalidType

+ const TokenMinUserTokenType

+ const TransitionACTION

+ const TransitionATOM

+ const TransitionEPSILON

+ const TransitionNOTSET

+ const TransitionPRECEDENCE

+ const TransitionPREDICATE

+ const TransitionRANGE

+ const TransitionRULE

+ const TransitionSET

+ const TransitionWILDCARD

+ var ATNInvalidAltNumber int

+ var ATNSimulatorError = NewDFAState(0x7FFFFFFF, NewBaseATNConfigSet(false))

+ var ATNStateInitialNumTransitions = 4

+ var BasePredictionContextEMPTY = NewEmptyPredictionContext()

+ var BasePredictionContextglobalNodeCount = 1

+ var BasePredictionContextid = BasePredictionContextglobalNodeCount

+ var CommonTokenFactoryDEFAULT = NewCommonTokenFactory(false)

+ var ConsoleErrorListenerINSTANCE = NewConsoleErrorListener()

+ var ErrEmptyStack = errors.New("Stack is empty")

+ var LexerATNSimulatorDFADebug = false

+ var LexerATNSimulatorDebug = false

+ var LexerATNSimulatorMatchCalls = 0

+ var LexerATNSimulatorMaxDFAEdge = 127

+ var LexerATNSimulatorMinDFAEdge = 0

+ var LexerMoreActionINSTANCE = NewLexerMoreAction()

+ var LexerPopModeActionINSTANCE = NewLexerPopModeAction()

+ var LexerSkipActionINSTANCE = NewLexerSkipAction()

+ var ParseTreeWalkerDefault = NewParseTreeWalker()

+ var ParserATNSimulatorDFADebug = false

+ var ParserATNSimulatorDebug = false

+ var ParserATNSimulatorRetryDebug = false

+ var ParserATNSimulatorTraceATNSim = false

+ var ParserRuleContextEmpty = NewBaseParserRuleContext(nil, -1)

+ var SemanticContextNone = NewPredicate(-1, -1, false)

+ var TransitionserializationNames = []string

+ var TreeInvalidInterval = NewInterval(-1, -2)

+ var TurnOffLRLoopEntryBranchOpt = false

+ func EscapeWhitespace(s string, escapeSpaces bool) string

+ func PredictionModeallConfigsInRuleStopStates(configs ATNConfigSet) bool

+ func PredictionModeallSubsetsConflict(altsets []*BitSet) bool

+ func PredictionModeallSubsetsEqual(altsets []*BitSet) bool

+ func PredictionModegetSingleViableAlt(altsets []*BitSet) int

+ func PredictionModegetUniqueAlt(altsets []*BitSet) int

+ func PredictionModehasConfigInRuleStopState(configs ATNConfigSet) bool

+ func PredictionModehasConflictingAltSet(altsets []*BitSet) bool

+ func PredictionModehasNonConflictingAltSet(altsets []*BitSet) bool

+ func PredictionModehasSLLConflictTerminatingPrediction(mode int, configs ATNConfigSet) bool

+ func PredictionModehasStateAssociatedWithOneAlt(configs ATNConfigSet) bool

+ func PredictionModeresolvesToJustOneViableAlt(altsets []*BitSet) int

+ func PrintArrayJavaStyle(sa []string) string

+ func TerminalNodeToStringArray(sa []TerminalNode) []string

+ func TreesGetNodeText(t Tree, ruleNames []string, recog Parser) string

+ func TreesStringTree(tree Tree, ruleNames []string, recog Recognizer) string

+ type AND struct

+ func NewAND(a, b SemanticContext) *AND

+ func (a *AND) Equals(other Collectable[SemanticContext]) bool

+ func (a *AND) Hash() int

+ func (a *AND) String() string

+ type ATN struct

+ DecisionToState []DecisionState

+ func NewATN(grammarType int, maxTokenType int) *ATN

+ func (a *ATN) NextTokens(s ATNState, ctx RuleContext) *IntervalSet

+ func (a *ATN) NextTokensInContext(s ATNState, ctx RuleContext) *IntervalSet

+ func (a *ATN) NextTokensNoContext(s ATNState) *IntervalSet

+ type ATNAltConfigComparator struct

+ func (c *ATNAltConfigComparator[T]) Equals2(o1, o2 ATNConfig) bool

+ func (c *ATNAltConfigComparator[T]) Hash1(o ATNConfig) int

+ type ATNConfig interface

+ Equals func(o Collectable[ATNConfig]) bool

+ GetAlt func() int

+ GetContext func() PredictionContext

+ GetReachesIntoOuterContext func() int

+ GetSemanticContext func() SemanticContext

+ GetState func() ATNState

+ Hash func() int

+ SetContext func(PredictionContext)

+ SetReachesIntoOuterContext func(int)

+ String func() string

+ func NewBaseATNConfig7(old *BaseATNConfig) ATNConfig

+ type ATNConfigComparator struct

+ func (c *ATNConfigComparator[T]) Equals2(o1, o2 ATNConfig) bool

+ func (c *ATNConfigComparator[T]) Hash1(o ATNConfig) int

+ type ATNConfigSet interface

+ Add func(ATNConfig, *DoubleDict) bool

+ AddAll func([]ATNConfig) bool

+ Alts func() *BitSet

+ Clear func()

+ Contains func(ATNConfig) bool

+ ContainsFast func(ATNConfig) bool

+ Equals func(o Collectable[ATNConfig]) bool

+ FullContext func() bool

+ GetConflictingAlts func() *BitSet

+ GetDipsIntoOuterContext func() bool

+ GetItems func() []ATNConfig

+ GetPredicates func() []SemanticContext

+ GetStates func() *JStore[ATNState, Comparator[ATNState]]

+ GetUniqueAlt func() int

+ HasSemanticContext func() bool

+ Hash func() int

+ IsEmpty func() bool

+ Length func() int

+ OptimizeConfigs func(interpreter *BaseATNSimulator)

+ ReadOnly func() bool

+ SetConflictingAlts func(*BitSet)

+ SetDipsIntoOuterContext func(bool)

+ SetHasSemanticContext func(v bool)

+ SetReadOnly func(bool)

+ SetUniqueAlt func(int)

+ String func() string

+ type ATNConfigSetPair struct

+ type ATNDeserializationOptions struct

+ func DefaultATNDeserializationOptions() *ATNDeserializationOptions

+ func NewATNDeserializationOptions(other *ATNDeserializationOptions) *ATNDeserializationOptions

+ func (opts *ATNDeserializationOptions) GenerateRuleBypassTransitions() bool

+ func (opts *ATNDeserializationOptions) ReadOnly() bool

+ func (opts *ATNDeserializationOptions) SetGenerateRuleBypassTransitions(generateRuleBypassTransitions bool)

+ func (opts *ATNDeserializationOptions) SetReadOnly(readOnly bool)

+ func (opts *ATNDeserializationOptions) SetVerifyATN(verifyATN bool)

+ func (opts *ATNDeserializationOptions) VerifyATN() bool

+ type ATNDeserializer struct

+ func NewATNDeserializer(options *ATNDeserializationOptions) *ATNDeserializer

+ func (a *ATNDeserializer) Deserialize(data []int32) *ATN

+ type ATNState interface

+ AddTransition func(Transition, int)

+ Equals func(Collectable[ATNState]) bool

+ GetATN func() *ATN

+ GetEpsilonOnlyTransitions func() bool

+ GetNextTokenWithinRule func() *IntervalSet

+ GetRuleIndex func() int

+ GetStateNumber func() int

+ GetStateType func() int

+ GetTransitions func() []Transition

+ Hash func() int

+ SetATN func(*ATN)

+ SetNextTokenWithinRule func(*IntervalSet)

+ SetRuleIndex func(int)

+ SetStateNumber func(int)

+ SetTransitions func([]Transition)

+ String func() string

+ type AbstractPredicateTransition interface

+ IAbstractPredicateTransitionFoo func()

+ type ActionTransition struct

+ func NewActionTransition(target ATNState, ruleIndex, actionIndex int, isCtxDependent bool) *ActionTransition

+ func (t *ActionTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *ActionTransition) String() string

+ type AltDict struct

+ func NewAltDict() *AltDict

+ func PredictionModeGetStateToAltMap(configs ATNConfigSet) *AltDict

+ func (a *AltDict) Get(key string) interface{}

+ type ArrayPredictionContext struct

+ func NewArrayPredictionContext(parents []PredictionContext, returnStates []int) *ArrayPredictionContext

+ func (a *ArrayPredictionContext) Equals(o interface{}) bool

+ func (a *ArrayPredictionContext) GetParent(index int) PredictionContext

+ func (a *ArrayPredictionContext) GetReturnStates() []int

+ func (a *ArrayPredictionContext) Hash() int

+ func (a *ArrayPredictionContext) String() string

+ type AtomTransition struct

+ func NewAtomTransition(target ATNState, intervalSet int) *AtomTransition

+ func (t *AtomTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *AtomTransition) String() string

+ type BailErrorStrategy struct

+ func NewBailErrorStrategy() *BailErrorStrategy

+ func (b *BailErrorStrategy) Recover(recognizer Parser, e RecognitionException)

+ func (b *BailErrorStrategy) RecoverInline(recognizer Parser) Token

+ func (b *BailErrorStrategy) Sync(recognizer Parser)

+ type BaseATNConfig struct

+ func NewBaseATNConfig(c ATNConfig, state ATNState, context PredictionContext, ...) *BaseATNConfig

+ func NewBaseATNConfig1(c ATNConfig, state ATNState, context PredictionContext) *BaseATNConfig

+ func NewBaseATNConfig2(c ATNConfig, semanticContext SemanticContext) *BaseATNConfig

+ func NewBaseATNConfig3(c ATNConfig, state ATNState, semanticContext SemanticContext) *BaseATNConfig

+ func NewBaseATNConfig4(c ATNConfig, state ATNState) *BaseATNConfig

+ func NewBaseATNConfig5(state ATNState, alt int, context PredictionContext, ...) *BaseATNConfig

+ func NewBaseATNConfig6(state ATNState, alt int, context PredictionContext) *BaseATNConfig

+ func (b *BaseATNConfig) Equals(o Collectable[ATNConfig]) bool

+ func (b *BaseATNConfig) GetAlt() int

+ func (b *BaseATNConfig) GetContext() PredictionContext

+ func (b *BaseATNConfig) GetReachesIntoOuterContext() int

+ func (b *BaseATNConfig) GetSemanticContext() SemanticContext

+ func (b *BaseATNConfig) GetState() ATNState

+ func (b *BaseATNConfig) Hash() int

+ func (b *BaseATNConfig) SetContext(v PredictionContext)

+ func (b *BaseATNConfig) SetReachesIntoOuterContext(v int)

+ func (b *BaseATNConfig) String() string

+ type BaseATNConfigComparator struct

+ func (c *BaseATNConfigComparator[T]) Equals2(o1, o2 ATNConfig) bool

+ func (c *BaseATNConfigComparator[T]) Hash1(o ATNConfig) int

+ type BaseATNConfigSet struct

+ func NewBaseATNConfigSet(fullCtx bool) *BaseATNConfigSet

+ func (b *BaseATNConfigSet) Add(config ATNConfig, mergeCache *DoubleDict) bool

+ func (b *BaseATNConfigSet) AddAll(coll []ATNConfig) bool

+ func (b *BaseATNConfigSet) Alts() *BitSet

+ func (b *BaseATNConfigSet) Clear()

+ func (b *BaseATNConfigSet) Compare(bs *BaseATNConfigSet) bool

+ func (b *BaseATNConfigSet) Contains(item ATNConfig) bool

+ func (b *BaseATNConfigSet) ContainsFast(item ATNConfig) bool

+ func (b *BaseATNConfigSet) Equals(other Collectable[ATNConfig]) bool

+ func (b *BaseATNConfigSet) FullContext() bool

+ func (b *BaseATNConfigSet) GetConflictingAlts() *BitSet

+ func (b *BaseATNConfigSet) GetDipsIntoOuterContext() bool

+ func (b *BaseATNConfigSet) GetItems() []ATNConfig

+ func (b *BaseATNConfigSet) GetPredicates() []SemanticContext

+ func (b *BaseATNConfigSet) GetStates() *JStore[ATNState, Comparator[ATNState]]

+ func (b *BaseATNConfigSet) GetUniqueAlt() int

+ func (b *BaseATNConfigSet) HasSemanticContext() bool

+ func (b *BaseATNConfigSet) Hash() int

+ func (b *BaseATNConfigSet) IsEmpty() bool

+ func (b *BaseATNConfigSet) Length() int

+ func (b *BaseATNConfigSet) OptimizeConfigs(interpreter *BaseATNSimulator)

+ func (b *BaseATNConfigSet) ReadOnly() bool

+ func (b *BaseATNConfigSet) SetConflictingAlts(v *BitSet)

+ func (b *BaseATNConfigSet) SetDipsIntoOuterContext(v bool)

+ func (b *BaseATNConfigSet) SetHasSemanticContext(v bool)

+ func (b *BaseATNConfigSet) SetReadOnly(readOnly bool)

+ func (b *BaseATNConfigSet) SetUniqueAlt(v int)

+ func (b *BaseATNConfigSet) String() string

+ type BaseATNSimulator struct

+ func NewBaseATNSimulator(atn *ATN, sharedContextCache *PredictionContextCache) *BaseATNSimulator

+ func (b *BaseATNSimulator) ATN() *ATN

+ func (b *BaseATNSimulator) DecisionToDFA() []*DFA

+ func (b *BaseATNSimulator) SharedContextCache() *PredictionContextCache

+ type BaseATNState struct

+ NextTokenWithinRule *IntervalSet

+ func NewBaseATNState() *BaseATNState

+ func (as *BaseATNState) AddTransition(trans Transition, index int)

+ func (as *BaseATNState) Equals(other Collectable[ATNState]) bool

+ func (as *BaseATNState) GetATN() *ATN

+ func (as *BaseATNState) GetEpsilonOnlyTransitions() bool

+ func (as *BaseATNState) GetNextTokenWithinRule() *IntervalSet

+ func (as *BaseATNState) GetRuleIndex() int

+ func (as *BaseATNState) GetStateNumber() int

+ func (as *BaseATNState) GetStateType() int

+ func (as *BaseATNState) GetTransitions() []Transition

+ func (as *BaseATNState) Hash() int

+ func (as *BaseATNState) SetATN(atn *ATN)

+ func (as *BaseATNState) SetNextTokenWithinRule(v *IntervalSet)

+ func (as *BaseATNState) SetRuleIndex(v int)

+ func (as *BaseATNState) SetStateNumber(stateNumber int)

+ func (as *BaseATNState) SetTransitions(t []Transition)

+ func (as *BaseATNState) String() string

+ type BaseAbstractPredicateTransition struct

+ func NewBasePredicateTransition(target ATNState) *BaseAbstractPredicateTransition

+ func (a *BaseAbstractPredicateTransition) IAbstractPredicateTransitionFoo()

+ type BaseBlockStartState struct

+ func NewBlockStartState() *BaseBlockStartState

+ type BaseDecisionState struct

+ func NewBaseDecisionState() *BaseDecisionState

+ type BaseInterpreterRuleContext struct

+ func NewBaseInterpreterRuleContext(parent BaseInterpreterRuleContext, invokingStateNumber, ruleIndex int) *BaseInterpreterRuleContext

+ type BaseLexer struct

+ ActionType int

+ Interpreter ILexerATNSimulator

+ TokenStartCharIndex int

+ TokenStartColumn int

+ TokenStartLine int

+ Virt Lexer

+ func NewBaseLexer(input CharStream) *BaseLexer

+ func (b *BaseLexer) Emit() Token

+ func (b *BaseLexer) EmitEOF() Token

+ func (b *BaseLexer) EmitToken(token Token)

+ func (b *BaseLexer) GetATN() *ATN

+ func (b *BaseLexer) GetAllTokens() []Token

+ func (b *BaseLexer) GetCharIndex() int

+ func (b *BaseLexer) GetCharPositionInLine() int

+ func (b *BaseLexer) GetInputStream() CharStream

+ func (b *BaseLexer) GetInterpreter() ILexerATNSimulator

+ func (b *BaseLexer) GetLine() int

+ func (b *BaseLexer) GetSourceName() string

+ func (b *BaseLexer) GetText() string

+ func (b *BaseLexer) GetTokenFactory() TokenFactory

+ func (b *BaseLexer) GetTokenSourceCharStreamPair() *TokenSourceCharStreamPair

+ func (b *BaseLexer) GetType() int

+ func (b *BaseLexer) More()

+ func (b *BaseLexer) NextToken() Token

+ func (b *BaseLexer) PopMode() int

+ func (b *BaseLexer) PushMode(m int)

+ func (b *BaseLexer) Recover(re RecognitionException)

+ func (b *BaseLexer) SetChannel(v int)

+ func (b *BaseLexer) SetInputStream(input CharStream)

+ func (b *BaseLexer) SetMode(m int)

+ func (b *BaseLexer) SetText(text string)

+ func (b *BaseLexer) SetType(t int)

+ func (b *BaseLexer) Skip()

+ type BaseLexerAction struct

+ func NewBaseLexerAction(action int) *BaseLexerAction

+ func (b *BaseLexerAction) Equals(other LexerAction) bool

+ func (b *BaseLexerAction) Hash() int

+ type BaseParseTreeListener struct

+ func (l *BaseParseTreeListener) EnterEveryRule(ctx ParserRuleContext)

+ func (l *BaseParseTreeListener) ExitEveryRule(ctx ParserRuleContext)

+ func (l *BaseParseTreeListener) VisitErrorNode(node ErrorNode)

+ func (l *BaseParseTreeListener) VisitTerminal(node TerminalNode)

+ type BaseParseTreeVisitor struct

+ func (v *BaseParseTreeVisitor) Visit(tree ParseTree) interface{}

+ func (v *BaseParseTreeVisitor) VisitChildren(node RuleNode) interface{}

+ func (v *BaseParseTreeVisitor) VisitErrorNode(node ErrorNode) interface{}

+ func (v *BaseParseTreeVisitor) VisitTerminal(node TerminalNode) interface{}

+ type BaseParser struct

+ BuildParseTrees bool

+ Interpreter *ParserATNSimulator

+ func NewBaseParser(input TokenStream) *BaseParser

+ func (p *BaseParser) AddParseListener(listener ParseTreeListener)

+ func (p *BaseParser) Consume() Token

+ func (p *BaseParser) DumpDFA()

+ func (p *BaseParser) EnterOuterAlt(localctx ParserRuleContext, altNum int)

+ func (p *BaseParser) EnterRecursionRule(localctx ParserRuleContext, state, ruleIndex, precedence int)

+ func (p *BaseParser) EnterRule(localctx ParserRuleContext, state, ruleIndex int)

+ func (p *BaseParser) ExitRule()

+ func (p *BaseParser) GetATN() *ATN

+ func (p *BaseParser) GetATNWithBypassAlts()

+ func (p *BaseParser) GetCurrentToken() Token

+ func (p *BaseParser) GetDFAStrings() string

+ func (p *BaseParser) GetErrorHandler() ErrorStrategy

+ func (p *BaseParser) GetExpectedTokens() *IntervalSet

+ func (p *BaseParser) GetExpectedTokensWithinCurrentRule() *IntervalSet

+ func (p *BaseParser) GetInputStream() IntStream

+ func (p *BaseParser) GetInterpreter() *ParserATNSimulator

+ func (p *BaseParser) GetInvokingContext(ruleIndex int) ParserRuleContext

+ func (p *BaseParser) GetParseListeners() []ParseTreeListener

+ func (p *BaseParser) GetParserRuleContext() ParserRuleContext

+ func (p *BaseParser) GetPrecedence() int

+ func (p *BaseParser) GetRuleIndex(ruleName string) int

+ func (p *BaseParser) GetRuleInvocationStack(c ParserRuleContext) []string

+ func (p *BaseParser) GetSourceName() string

+ func (p *BaseParser) GetTokenFactory() TokenFactory

+ func (p *BaseParser) GetTokenStream() TokenStream

+ func (p *BaseParser) IsExpectedToken(symbol int) bool

+ func (p *BaseParser) Match(ttype int) Token

+ func (p *BaseParser) MatchWildcard() Token

+ func (p *BaseParser) NotifyErrorListeners(msg string, offendingToken Token, err RecognitionException)

+ func (p *BaseParser) Precpred(localctx RuleContext, precedence int) bool

+ func (p *BaseParser) PushNewRecursionContext(localctx ParserRuleContext, state, ruleIndex int)

+ func (p *BaseParser) RemoveParseListener(listener ParseTreeListener)

+ func (p *BaseParser) SetErrorHandler(e ErrorStrategy)

+ func (p *BaseParser) SetInputStream(input TokenStream)

+ func (p *BaseParser) SetParserRuleContext(v ParserRuleContext)

+ func (p *BaseParser) SetTokenStream(input TokenStream)

+ func (p *BaseParser) SetTrace(trace *TraceListener)

+ func (p *BaseParser) TriggerEnterRuleEvent()

+ func (p *BaseParser) TriggerExitRuleEvent()

+ func (p *BaseParser) UnrollRecursionContexts(parentCtx ParserRuleContext)

+ type BaseParserRuleContext struct

+ func NewBaseParserRuleContext(parent ParserRuleContext, invokingStateNumber int) *BaseParserRuleContext

+ func (prc *BaseParserRuleContext) Accept(visitor ParseTreeVisitor) interface{}

+ func (prc *BaseParserRuleContext) AddChild(child RuleContext) RuleContext

+ func (prc *BaseParserRuleContext) AddErrorNode(badToken Token) *ErrorNodeImpl

+ func (prc *BaseParserRuleContext) AddTokenNode(token Token) *TerminalNodeImpl

+ func (prc *BaseParserRuleContext) CopyFrom(ctx *BaseParserRuleContext)

+ func (prc *BaseParserRuleContext) EnterRule(listener ParseTreeListener)

+ func (prc *BaseParserRuleContext) ExitRule(listener ParseTreeListener)

+ func (prc *BaseParserRuleContext) GetChild(i int) Tree

+ func (prc *BaseParserRuleContext) GetChildCount() int

+ func (prc *BaseParserRuleContext) GetChildOfType(i int, childType reflect.Type) RuleContext

+ func (prc *BaseParserRuleContext) GetChildren() []Tree

+ func (prc *BaseParserRuleContext) GetPayload() interface{}

+ func (prc *BaseParserRuleContext) GetRuleContext() RuleContext

+ func (prc *BaseParserRuleContext) GetSourceInterval() *Interval

+ func (prc *BaseParserRuleContext) GetStart() Token

+ func (prc *BaseParserRuleContext) GetStop() Token

+ func (prc *BaseParserRuleContext) GetText() string

+ func (prc *BaseParserRuleContext) GetToken(ttype int, i int) TerminalNode

+ func (prc *BaseParserRuleContext) GetTokens(ttype int) []TerminalNode

+ func (prc *BaseParserRuleContext) GetTypedRuleContext(ctxType reflect.Type, i int) RuleContext

+ func (prc *BaseParserRuleContext) GetTypedRuleContexts(ctxType reflect.Type) []RuleContext

+ func (prc *BaseParserRuleContext) RemoveLastChild()

+ func (prc *BaseParserRuleContext) SetException(e RecognitionException)

+ func (prc *BaseParserRuleContext) SetStart(t Token)

+ func (prc *BaseParserRuleContext) SetStop(t Token)

+ func (prc *BaseParserRuleContext) String(ruleNames []string, stop RuleContext) string

+ func (prc *BaseParserRuleContext) ToStringTree(ruleNames []string, recog Recognizer) string

+ type BasePredictionContext struct

+ func NewBasePredictionContext(cachedHash int) *BasePredictionContext

+ type BaseRecognitionException struct

+ func NewBaseRecognitionException(message string, recognizer Recognizer, input IntStream, ctx RuleContext) *BaseRecognitionException

+ func (b *BaseRecognitionException) GetInputStream() IntStream

+ func (b *BaseRecognitionException) GetMessage() string

+ func (b *BaseRecognitionException) GetOffendingToken() Token

+ func (b *BaseRecognitionException) String() string

+ type BaseRecognizer struct

+ GrammarFileName string

+ LiteralNames []string

+ RuleNames []string

+ SymbolicNames []string

+ func NewBaseRecognizer() *BaseRecognizer

+ func (b *BaseRecognizer) Action(context RuleContext, ruleIndex, actionIndex int)

+ func (b *BaseRecognizer) AddErrorListener(listener ErrorListener)

+ func (b *BaseRecognizer) GetErrorHeader(e RecognitionException) string

+ func (b *BaseRecognizer) GetErrorListenerDispatch() ErrorListener

+ func (b *BaseRecognizer) GetLiteralNames() []string

+ func (b *BaseRecognizer) GetRuleIndexMap() map[string]int

+ func (b *BaseRecognizer) GetRuleNames() []string

+ func (b *BaseRecognizer) GetState() int

+ func (b *BaseRecognizer) GetSymbolicNames() []string

+ func (b *BaseRecognizer) GetTokenErrorDisplay(t Token) string

+ func (b *BaseRecognizer) GetTokenNames() []string

+ func (b *BaseRecognizer) GetTokenType(tokenName string) int

+ func (b *BaseRecognizer) Precpred(localctx RuleContext, precedence int) bool

+ func (b *BaseRecognizer) RemoveErrorListeners()

+ func (b *BaseRecognizer) Sempred(localctx RuleContext, ruleIndex int, actionIndex int) bool

+ func (b *BaseRecognizer) SetState(v int)

+ type BaseRewriteOperation struct

+ func (op *BaseRewriteOperation) Execute(buffer *bytes.Buffer) int

+ func (op *BaseRewriteOperation) GetIndex() int

+ func (op *BaseRewriteOperation) GetInstructionIndex() int

+ func (op *BaseRewriteOperation) GetOpName() string

+ func (op *BaseRewriteOperation) GetText() string

+ func (op *BaseRewriteOperation) GetTokens() TokenStream

+ func (op *BaseRewriteOperation) SetIndex(val int)

+ func (op *BaseRewriteOperation) SetInstructionIndex(val int)

+ func (op *BaseRewriteOperation) SetOpName(val string)

+ func (op *BaseRewriteOperation) SetText(val string)

+ func (op *BaseRewriteOperation) SetTokens(val TokenStream)

+ func (op *BaseRewriteOperation) String() string

+ type BaseRuleContext struct

+ RuleIndex int

+ func NewBaseRuleContext(parent RuleContext, invokingState int) *BaseRuleContext

+ func (b *BaseRuleContext) GetAltNumber() int

+ func (b *BaseRuleContext) GetBaseRuleContext() *BaseRuleContext

+ func (b *BaseRuleContext) GetInvokingState() int

+ func (b *BaseRuleContext) GetParent() Tree

+ func (b *BaseRuleContext) GetRuleIndex() int

+ func (b *BaseRuleContext) IsEmpty() bool

+ func (b *BaseRuleContext) SetAltNumber(altNumber int)

+ func (b *BaseRuleContext) SetInvokingState(t int)

+ func (b *BaseRuleContext) SetParent(v Tree)

+ type BaseSingletonPredictionContext struct

+ func NewBaseSingletonPredictionContext(parent PredictionContext, returnState int) *BaseSingletonPredictionContext

+ func (b *BaseSingletonPredictionContext) Equals(other interface{}) bool

+ func (b *BaseSingletonPredictionContext) GetParent(index int) PredictionContext

+ func (b *BaseSingletonPredictionContext) Hash() int

+ func (b *BaseSingletonPredictionContext) String() string

+ type BaseToken struct

+ func (b *BaseToken) GetChannel() int

+ func (b *BaseToken) GetColumn() int

+ func (b *BaseToken) GetInputStream() CharStream

+ func (b *BaseToken) GetLine() int

+ func (b *BaseToken) GetSource() *TokenSourceCharStreamPair

+ func (b *BaseToken) GetStart() int

+ func (b *BaseToken) GetStop() int

+ func (b *BaseToken) GetTokenIndex() int

+ func (b *BaseToken) GetTokenSource() TokenSource

+ func (b *BaseToken) GetTokenType() int

+ func (b *BaseToken) SetTokenIndex(v int)

+ type BaseTransition struct

+ func NewBaseTransition(target ATNState) *BaseTransition

+ func (t *BaseTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ type BasicBlockStartState struct

+ func NewBasicBlockStartState() *BasicBlockStartState

+ type BasicState struct

+ func NewBasicState() *BasicState

+ type BitSet struct

+ func NewBitSet() *BitSet

+ func PredictionModeGetAlts(altsets []*BitSet) *BitSet

+ func PredictionModegetConflictingAltSubsets(configs ATNConfigSet) []*BitSet

+ func (b *BitSet) String() string

+ type BlockEndState struct

+ func NewBlockEndState() *BlockEndState

+ type BlockStartState interface

+ type CharStream interface

+ GetText func(int, int) string

+ GetTextFromInterval func(*Interval) string

+ GetTextFromTokens func(start, end Token) string

+ type Collectable interface

+ Equals func(other Collectable[T]) bool

+ Hash func() int

+ type CommonToken struct

+ func NewCommonToken(source *TokenSourceCharStreamPair, tokenType, channel, start, stop int) *CommonToken

+ func (c *CommonToken) GetText() string

+ func (c *CommonToken) SetText(text string)

+ func (c *CommonToken) String() string

+ type CommonTokenFactory struct

+ func NewCommonTokenFactory(copyText bool) *CommonTokenFactory

+ func (c *CommonTokenFactory) Create(source *TokenSourceCharStreamPair, ttype int, text string, ...) Token

+ type CommonTokenStream struct

+ func NewCommonTokenStream(lexer Lexer, channel int) *CommonTokenStream

+ func (c *CommonTokenStream) Consume()

+ func (c *CommonTokenStream) Fill()

+ func (c *CommonTokenStream) Get(index int) Token

+ func (c *CommonTokenStream) GetAllText() string

+ func (c *CommonTokenStream) GetAllTokens() []Token

+ func (c *CommonTokenStream) GetHiddenTokensToLeft(tokenIndex, channel int) []Token

+ func (c *CommonTokenStream) GetHiddenTokensToRight(tokenIndex, channel int) []Token

+ func (c *CommonTokenStream) GetSourceName() string

+ func (c *CommonTokenStream) GetTextFromInterval(interval *Interval) string

+ func (c *CommonTokenStream) GetTextFromRuleContext(interval RuleContext) string

+ func (c *CommonTokenStream) GetTextFromTokens(start, end Token) string

+ func (c *CommonTokenStream) GetTokenSource() TokenSource

+ func (c *CommonTokenStream) GetTokens(start int, stop int, types *IntervalSet) []Token

+ func (c *CommonTokenStream) Index() int

+ func (c *CommonTokenStream) LA(i int) int

+ func (c *CommonTokenStream) LB(k int) Token

+ func (c *CommonTokenStream) LT(k int) Token

+ func (c *CommonTokenStream) Mark() int

+ func (c *CommonTokenStream) NextTokenOnChannel(i, channel int) int

+ func (c *CommonTokenStream) Release(marker int)

+ func (c *CommonTokenStream) Seek(index int)

+ func (c *CommonTokenStream) SetTokenSource(tokenSource TokenSource)

+ func (c *CommonTokenStream) Size() int

+ func (c *CommonTokenStream) Sync(i int) bool

+ type Comparator interface

+ Equals2 func(T, T) bool

+ Hash1 func(o T) int

+ type ConsoleErrorListener struct

+ func NewConsoleErrorListener() *ConsoleErrorListener

+ func (c *ConsoleErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, ...)

+ type DFA struct

+ func NewDFA(atnStartState DecisionState, decision int) *DFA

+ func (d *DFA) String(literalNames []string, symbolicNames []string) string

+ func (d *DFA) ToLexerString() string

+ type DFASerializer struct

+ func NewDFASerializer(dfa *DFA, literalNames, symbolicNames []string) *DFASerializer

+ func (d *DFASerializer) GetStateString(s *DFAState) string

+ func (d *DFASerializer) String() string

+ type DFAState struct

+ func NewDFAState(stateNumber int, configs ATNConfigSet) *DFAState

+ func (d *DFAState) Equals(o Collectable[*DFAState]) bool

+ func (d *DFAState) GetAltSet() []int

+ func (d *DFAState) Hash() int

+ func (d *DFAState) String() string

+ type DecisionState interface

+ type DefaultErrorListener struct

+ func NewDefaultErrorListener() *DefaultErrorListener

+ func (d *DefaultErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ...)

+ func (d *DefaultErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, ...)

+ func (d *DefaultErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, ...)

+ func (d *DefaultErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, ...)

+ type DefaultErrorStrategy struct

+ func NewDefaultErrorStrategy() *DefaultErrorStrategy

+ func (d *DefaultErrorStrategy) GetExpectedTokens(recognizer Parser) *IntervalSet

+ func (d *DefaultErrorStrategy) GetMissingSymbol(recognizer Parser) Token

+ func (d *DefaultErrorStrategy) GetTokenErrorDisplay(t Token) string

+ func (d *DefaultErrorStrategy) InErrorRecoveryMode(recognizer Parser) bool

+ func (d *DefaultErrorStrategy) Recover(recognizer Parser, e RecognitionException)

+ func (d *DefaultErrorStrategy) RecoverInline(recognizer Parser) Token

+ func (d *DefaultErrorStrategy) ReportError(recognizer Parser, e RecognitionException)

+ func (d *DefaultErrorStrategy) ReportFailedPredicate(recognizer Parser, e *FailedPredicateException)

+ func (d *DefaultErrorStrategy) ReportMatch(recognizer Parser)

+ func (d *DefaultErrorStrategy) ReportMissingToken(recognizer Parser)

+ func (d *DefaultErrorStrategy) ReportNoViableAlternative(recognizer Parser, e *NoViableAltException)

+ func (d *DefaultErrorStrategy) ReportUnwantedToken(recognizer Parser)

+ func (d *DefaultErrorStrategy) SingleTokenDeletion(recognizer Parser) Token

+ func (d *DefaultErrorStrategy) SingleTokenInsertion(recognizer Parser) bool

+ func (d *DefaultErrorStrategy) Sync(recognizer Parser)

+ func (this *DefaultErrorStrategy) ReportInputMisMatch(recognizer Parser, e *InputMisMatchException)

+ type DiagnosticErrorListener struct

+ func NewDiagnosticErrorListener(exactOnly bool) *DiagnosticErrorListener

+ func (d *DiagnosticErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ...)

+ func (d *DiagnosticErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, ...)

+ func (d *DiagnosticErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, ...)

+ type DoubleDict struct

+ func NewDoubleDict() *DoubleDict

+ func (d *DoubleDict) Get(a, b int) interface{}

+ type EmptyPredictionContext struct

+ func NewEmptyPredictionContext() *EmptyPredictionContext

+ func (e *EmptyPredictionContext) Equals(other interface{}) bool

+ func (e *EmptyPredictionContext) GetParent(index int) PredictionContext

+ func (e *EmptyPredictionContext) Hash() int

+ func (e *EmptyPredictionContext) String() string

+ type EpsilonTransition struct

+ func NewEpsilonTransition(target ATNState, outermostPrecedenceReturn int) *EpsilonTransition

+ func (t *EpsilonTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *EpsilonTransition) String() string

+ type ErrorListener interface

+ ReportAmbiguity func(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ...)

+ ReportAttemptingFullContext func(recognizer Parser, dfa *DFA, startIndex, stopIndex int, ...)

+ ReportContextSensitivity func(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, ...)

+ SyntaxError func(recognizer Recognizer, offendingSymbol interface{}, line, column int, ...)

+ type ErrorNode interface

+ type ErrorNodeImpl struct

+ func NewErrorNodeImpl(token Token) *ErrorNodeImpl

+ func (e *ErrorNodeImpl) Accept(v ParseTreeVisitor) interface{}

+ type ErrorStrategy interface

+ InErrorRecoveryMode func(Parser) bool

+ Recover func(Parser, RecognitionException)

+ RecoverInline func(Parser) Token

+ ReportError func(Parser, RecognitionException)

+ ReportMatch func(Parser)

+ Sync func(Parser)

+ type FailedPredicateException struct

+ func NewFailedPredicateException(recognizer Parser, predicate string, message string) *FailedPredicateException

+ type FileStream struct

+ func NewFileStream(fileName string) (*FileStream, error)

+ func (f *FileStream) GetSourceName() string

+ type IATNSimulator interface

+ ATN func() *ATN

+ DecisionToDFA func() []*DFA

+ SharedContextCache func() *PredictionContextCache

+ type ILexerATNSimulator interface

+ Consume func(input CharStream)

+ GetCharPositionInLine func() int

+ GetLine func() int

+ GetText func(input CharStream) string

+ Match func(input CharStream, mode int) int

+ type InputMisMatchException struct

+ func NewInputMisMatchException(recognizer Parser) *InputMisMatchException

+ type InputStream struct

+ func NewInputStream(data string) *InputStream

+ func (*InputStream) GetSourceName() string

+ func (is *InputStream) Consume()

+ func (is *InputStream) GetText(start int, stop int) string

+ func (is *InputStream) GetTextFromInterval(i *Interval) string

+ func (is *InputStream) GetTextFromTokens(start, stop Token) string

+ func (is *InputStream) Index() int

+ func (is *InputStream) LA(offset int) int

+ func (is *InputStream) LT(offset int) int

+ func (is *InputStream) Mark() int

+ func (is *InputStream) Release(marker int)

+ func (is *InputStream) Seek(index int)

+ func (is *InputStream) Size() int

+ func (is *InputStream) String() string

+ type InsertAfterOp struct

+ func NewInsertAfterOp(index int, text string, stream TokenStream) *InsertAfterOp

+ func (op *InsertAfterOp) Execute(buffer *bytes.Buffer) int

+ func (op *InsertAfterOp) String() string

+ type InsertBeforeOp struct

+ func NewInsertBeforeOp(index int, text string, stream TokenStream) *InsertBeforeOp

+ func (op *InsertBeforeOp) Execute(buffer *bytes.Buffer) int

+ func (op *InsertBeforeOp) String() string

+ type IntStack []int

+ func (s *IntStack) Pop() (int, error)

+ func (s *IntStack) Push(e int)

+ type IntStream interface

+ Consume func()

+ GetSourceName func() string

+ Index func() int

+ LA func(int) int

+ Mark func() int

+ Release func(marker int)

+ Seek func(index int)

+ Size func() int

+ type InterpreterRuleContext interface

+ type Interval struct

+ Start int

+ Stop int

+ func NewInterval(start, stop int) *Interval

+ func (i *Interval) Contains(item int) bool

+ func (i *Interval) String() string

+ type IntervalSet struct

+ func NewIntervalSet() *IntervalSet

+ func (i *IntervalSet) GetIntervals() []*Interval

+ func (i *IntervalSet) String() string

+ func (i *IntervalSet) StringVerbose(literalNames []string, symbolicNames []string, elemsAreChar bool) string

+ type JMap struct

+ func NewJMap(comparator Comparator[K]) *JMap[K, V, C]

+ func (m *JMap[K, V, C]) Clear()

+ func (m *JMap[K, V, C]) Delete(key K)

+ func (m *JMap[K, V, C]) Get(key K) (V, bool)

+ func (m *JMap[K, V, C]) Len() int

+ func (m *JMap[K, V, C]) Put(key K, val V)

+ func (m *JMap[K, V, C]) Values() []V

+ type JStore struct

+ func NewJStore(comparator Comparator[T]) *JStore[T, C]

+ func (s *JStore[T, C]) Contains(key T) bool

+ func (s *JStore[T, C]) Each(f func(T) bool)

+ func (s *JStore[T, C]) Get(key T) (T, bool)

+ func (s *JStore[T, C]) Len() int

+ func (s *JStore[T, C]) Put(value T) (v T, exists bool)

+ func (s *JStore[T, C]) SortedSlice(less func(i, j T) bool) []T

+ func (s *JStore[T, C]) Values() []T

+ type LL1Analyzer struct

+ func NewLL1Analyzer(atn *ATN) *LL1Analyzer

+ func (la *LL1Analyzer) Look(s, stopState ATNState, ctx RuleContext) *IntervalSet

+ type Lexer interface

+ Emit func() Token

+ PopMode func() int

+ PushMode func(int)

+ SetChannel func(int)

+ SetMode func(int)

+ SetType func(int)

+ type LexerATNConfig struct

+ func NewLexerATNConfig1(state ATNState, alt int, context PredictionContext) *LexerATNConfig

+ func NewLexerATNConfig2(c *LexerATNConfig, state ATNState, context PredictionContext) *LexerATNConfig

+ func NewLexerATNConfig3(c *LexerATNConfig, state ATNState, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig

+ func NewLexerATNConfig4(c *LexerATNConfig, state ATNState) *LexerATNConfig

+ func NewLexerATNConfig5(state ATNState, alt int, context PredictionContext, ...) *LexerATNConfig

+ func NewLexerATNConfig6(state ATNState, alt int, context PredictionContext) *LexerATNConfig

+ func (l *LexerATNConfig) Equals(other Collectable[ATNConfig]) bool

+ func (l *LexerATNConfig) Hash() int

+ type LexerATNSimulator struct

+ CharPositionInLine int

+ Line int

+ MatchCalls int

+ func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, ...) *LexerATNSimulator

+ func (l *LexerATNSimulator) Consume(input CharStream)

+ func (l *LexerATNSimulator) GetCharPositionInLine() int

+ func (l *LexerATNSimulator) GetLine() int

+ func (l *LexerATNSimulator) GetText(input CharStream) string

+ func (l *LexerATNSimulator) GetTokenName(tt int) string

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

+ func (l *LexerATNSimulator) MatchATN(input CharStream) int

+ type LexerAction interface

+ Equals func(other LexerAction) bool

+ Hash func() int

+ type LexerActionExecutor struct

+ func LexerActionExecutorappend(lexerActionExecutor *LexerActionExecutor, lexerAction LexerAction) *LexerActionExecutor

+ func NewLexerActionExecutor(lexerActions []LexerAction) *LexerActionExecutor

+ func (l *LexerActionExecutor) Equals(other interface{}) bool

+ func (l *LexerActionExecutor) Hash() int

+ type LexerChannelAction struct

+ func NewLexerChannelAction(channel int) *LexerChannelAction

+ func (l *LexerChannelAction) Equals(other LexerAction) bool

+ func (l *LexerChannelAction) Hash() int

+ func (l *LexerChannelAction) String() string

+ type LexerCustomAction struct

+ func NewLexerCustomAction(ruleIndex, actionIndex int) *LexerCustomAction

+ func (l *LexerCustomAction) Equals(other LexerAction) bool

+ func (l *LexerCustomAction) Hash() int

+ type LexerDFASerializer struct

+ func NewLexerDFASerializer(dfa *DFA) *LexerDFASerializer

+ func (l *LexerDFASerializer) String() string

+ type LexerIndexedCustomAction struct

+ func NewLexerIndexedCustomAction(offset int, lexerAction LexerAction) *LexerIndexedCustomAction

+ func (l *LexerIndexedCustomAction) Hash() int

+ type LexerModeAction struct

+ func NewLexerModeAction(mode int) *LexerModeAction

+ func (l *LexerModeAction) Equals(other LexerAction) bool

+ func (l *LexerModeAction) Hash() int

+ func (l *LexerModeAction) String() string

+ type LexerMoreAction struct

+ func NewLexerMoreAction() *LexerMoreAction

+ func (l *LexerMoreAction) String() string

+ type LexerNoViableAltException struct

+ func NewLexerNoViableAltException(lexer Lexer, input CharStream, startIndex int, deadEndConfigs ATNConfigSet) *LexerNoViableAltException

+ func (l *LexerNoViableAltException) String() string

+ type LexerPopModeAction struct

+ func NewLexerPopModeAction() *LexerPopModeAction

+ func (l *LexerPopModeAction) String() string

+ type LexerPushModeAction struct

+ func NewLexerPushModeAction(mode int) *LexerPushModeAction

+ func (l *LexerPushModeAction) Equals(other LexerAction) bool

+ func (l *LexerPushModeAction) Hash() int

+ func (l *LexerPushModeAction) String() string

+ type LexerSkipAction struct

+ func NewLexerSkipAction() *LexerSkipAction

+ func (l *LexerSkipAction) String() string

+ type LexerTypeAction struct

+ func NewLexerTypeAction(thetype int) *LexerTypeAction

+ func (l *LexerTypeAction) Equals(other LexerAction) bool

+ func (l *LexerTypeAction) Hash() int

+ func (l *LexerTypeAction) String() string

+ type LoopEndState struct

+ func NewLoopEndState() *LoopEndState

+ type NoViableAltException struct

+ func NewNoViableAltException(recognizer Parser, input TokenStream, startToken Token, offendingToken Token, ...) *NoViableAltException

+ type NotSetTransition struct

+ func NewNotSetTransition(target ATNState, set *IntervalSet) *NotSetTransition

+ func (t *NotSetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *NotSetTransition) String() string

+ type OR struct

+ func NewOR(a, b SemanticContext) *OR

+ func (a *OR) Hash() int

+ func (o *OR) Equals(other Collectable[SemanticContext]) bool

+ func (o *OR) String() string

+ type ObjEqComparator struct

+ func (c *ObjEqComparator[T]) Equals2(o1, o2 T) bool

+ func (c *ObjEqComparator[T]) Hash1(o T) int

+ type OrderedATNConfigSet struct

+ func NewOrderedATNConfigSet() *OrderedATNConfigSet

+ type ParseCancellationException struct

+ func NewParseCancellationException() *ParseCancellationException

+ type ParseTree interface

+ Accept func(Visitor ParseTreeVisitor) interface{}

+ GetText func() string

+ ToStringTree func([]string, Recognizer) string

+ func TreesDescendants(t ParseTree) []ParseTree

+ func TreesFindAllTokenNodes(t ParseTree, ttype int) []ParseTree

+ func TreesfindAllNodes(t ParseTree, index int, findTokens bool) []ParseTree

+ func TreesfindAllRuleNodes(t ParseTree, ruleIndex int) []ParseTree

+ type ParseTreeListener interface

+ EnterEveryRule func(ctx ParserRuleContext)

+ ExitEveryRule func(ctx ParserRuleContext)

+ VisitErrorNode func(node ErrorNode)

+ VisitTerminal func(node TerminalNode)

+ type ParseTreeVisitor interface

+ Visit func(tree ParseTree) interface{}

+ VisitChildren func(node RuleNode) interface{}

+ VisitErrorNode func(node ErrorNode) interface{}

+ VisitTerminal func(node TerminalNode) interface{}

+ type ParseTreeWalker struct

+ func NewParseTreeWalker() *ParseTreeWalker

+ func (p *ParseTreeWalker) EnterRule(listener ParseTreeListener, r RuleNode)

+ func (p *ParseTreeWalker) ExitRule(listener ParseTreeListener, r RuleNode)

+ func (p *ParseTreeWalker) Walk(listener ParseTreeListener, t Tree)

+ type Parser interface

+ Consume func() Token

+ GetCurrentToken func() Token

+ GetErrorHandler func() ErrorStrategy

+ GetExpectedTokens func() *IntervalSet

+ GetInputStream func() IntStream

+ GetInterpreter func() *ParserATNSimulator

+ GetParseListeners func() []ParseTreeListener

+ GetParserRuleContext func() ParserRuleContext

+ GetPrecedence func() int

+ GetRuleInvocationStack func(ParserRuleContext) []string

+ GetTokenFactory func() TokenFactory

+ GetTokenStream func() TokenStream

+ IsExpectedToken func(int) bool

+ NotifyErrorListeners func(string, Token, RecognitionException)

+ SetErrorHandler func(ErrorStrategy)

+ SetParserRuleContext func(ParserRuleContext)

+ type ParserATNSimulator struct

+ func NewParserATNSimulator(parser Parser, atn *ATN, decisionToDFA []*DFA, ...) *ParserATNSimulator

+ func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, outerContext ParserRuleContext) int

+ func (p *ParserATNSimulator) GetAltThatFinishedDecisionEntryRule(configs ATNConfigSet) int

+ func (p *ParserATNSimulator) GetPredictionMode() int

+ func (p *ParserATNSimulator) GetTokenName(t int) string

+ func (p *ParserATNSimulator) ReportAmbiguity(dfa *DFA, D *DFAState, startIndex, stopIndex int, exact bool, ...)

+ func (p *ParserATNSimulator) ReportAttemptingFullContext(dfa *DFA, conflictingAlts *BitSet, configs ATNConfigSet, ...)

+ func (p *ParserATNSimulator) ReportContextSensitivity(dfa *DFA, prediction int, configs ATNConfigSet, startIndex, stopIndex int)

+ func (p *ParserATNSimulator) SetPredictionMode(v int)

+ type ParserRuleContext interface

+ AddChild func(child RuleContext) RuleContext

+ AddErrorNode func(badToken Token) *ErrorNodeImpl

+ AddTokenNode func(token Token) *TerminalNodeImpl

+ EnterRule func(listener ParseTreeListener)

+ ExitRule func(listener ParseTreeListener)

+ GetStart func() Token

+ GetStop func() Token

+ RemoveLastChild func()

+ SetException func(RecognitionException)

+ SetStart func(Token)

+ SetStop func(Token)

+ type PlusBlockStartState struct

+ func NewPlusBlockStartState() *PlusBlockStartState

+ type PlusLoopbackState struct

+ func NewPlusLoopbackState() *PlusLoopbackState

+ type PrecedencePredicate struct

+ func NewPrecedencePredicate(precedence int) *PrecedencePredicate

+ func PrecedencePredicatefilterPrecedencePredicates(set *JStore[SemanticContext, Comparator[SemanticContext]]) []*PrecedencePredicate

+ func (p *PrecedencePredicate) Equals(other Collectable[SemanticContext]) bool

+ func (p *PrecedencePredicate) Hash() int

+ func (p *PrecedencePredicate) String() string

+ type PrecedencePredicateTransition struct

+ func NewPrecedencePredicateTransition(target ATNState, precedence int) *PrecedencePredicateTransition

+ func (t *PrecedencePredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *PrecedencePredicateTransition) String() string

+ type PredPrediction struct

+ func NewPredPrediction(pred SemanticContext, alt int) *PredPrediction

+ func (p *PredPrediction) String() string

+ type Predicate struct

+ func NewPredicate(ruleIndex, predIndex int, isCtxDependent bool) *Predicate

+ func (p *Predicate) Equals(other Collectable[SemanticContext]) bool

+ func (p *Predicate) Hash() int

+ func (p *Predicate) String() string

+ type PredicateTransition struct

+ func NewPredicateTransition(target ATNState, ruleIndex, predIndex int, isCtxDependent bool) *PredicateTransition

+ func (t *PredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *PredicateTransition) String() string

+ type PredictionContext interface

+ Equals func(interface{}) bool

+ GetParent func(int) PredictionContext

+ Hash func() int

+ String func() string

+ func SingletonBasePredictionContextCreate(parent PredictionContext, returnState int) PredictionContext

+ type PredictionContextCache struct

+ func NewPredictionContextCache() *PredictionContextCache

+ func (p *PredictionContextCache) Get(ctx PredictionContext) PredictionContext

+ type ProxyErrorListener struct

+ func NewProxyErrorListener(delegates []ErrorListener) *ProxyErrorListener

+ func (p *ProxyErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ...)

+ func (p *ProxyErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, ...)

+ func (p *ProxyErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, ...)

+ func (p *ProxyErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, ...)

+ type RangeTransition struct

+ func NewRangeTransition(target ATNState, start, stop int) *RangeTransition

+ func (t *RangeTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *RangeTransition) String() string

+ type RecognitionException interface

+ GetInputStream func() IntStream

+ GetMessage func() string

+ GetOffendingToken func() Token

+ type Recognizer interface

+ Action func(RuleContext, int, int)

+ AddErrorListener func(ErrorListener)

+ GetATN func() *ATN

+ GetErrorListenerDispatch func() ErrorListener

+ GetLiteralNames func() []string

+ GetRuleNames func() []string

+ GetState func() int

+ GetSymbolicNames func() []string

+ Precpred func(RuleContext, int) bool

+ RemoveErrorListeners func()

+ Sempred func(RuleContext, int, int) bool

+ SetState func(int)

+ type ReplaceOp struct

+ LastIndex int

+ func NewReplaceOp(from, to int, text string, stream TokenStream) *ReplaceOp

+ func (op *ReplaceOp) Execute(buffer *bytes.Buffer) int

+ func (op *ReplaceOp) String() string

+ type RewriteOperation interface

+ Execute func(buffer *bytes.Buffer) int

+ GetIndex func() int

+ GetInstructionIndex func() int

+ GetOpName func() string

+ GetText func() string

+ GetTokens func() TokenStream

+ SetIndex func(int)

+ SetInstructionIndex func(val int)

+ SetOpName func(string)

+ SetText func(string)

+ SetTokens func(TokenStream)

+ String func() string

+ type RuleContext interface

+ GetAltNumber func() int

+ GetInvokingState func() int

+ GetRuleIndex func() int

+ IsEmpty func() bool

+ SetAltNumber func(altNumber int)

+ SetInvokingState func(int)

+ String func([]string, RuleContext) string

+ type RuleNode interface

+ GetBaseRuleContext func() *BaseRuleContext

+ GetRuleContext func() RuleContext

+ type RuleStartState struct

+ func NewRuleStartState() *RuleStartState

+ type RuleStopState struct

+ func NewRuleStopState() *RuleStopState

+ type RuleTransition struct

+ func NewRuleTransition(ruleStart ATNState, ruleIndex, precedence int, followState ATNState) *RuleTransition

+ func (t *RuleTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ type SemCComparator struct

+ type SemanticContext interface

+ Equals func(other Collectable[SemanticContext]) bool

+ Hash func() int

+ String func() string

+ func SemanticContextandContext(a, b SemanticContext) SemanticContext

+ func SemanticContextorContext(a, b SemanticContext) SemanticContext

+ type Set interface

+ Add func(value interface{}) (added interface{})

+ Contains func(value interface{}) bool

+ Each func(f func(interface{}) bool)

+ Get func(value interface{}) (found interface{})

+ Len func() int

+ Values func() []interface{}

+ type SetTransition struct

+ func NewSetTransition(target ATNState, set *IntervalSet) *SetTransition

+ func (t *SetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *SetTransition) String() string

+ type SimState struct

+ func NewSimState() *SimState

+ type SingletonPredictionContext interface

+ type StarBlockStartState struct

+ func NewStarBlockStartState() *StarBlockStartState

+ type StarLoopEntryState struct

+ func NewStarLoopEntryState() *StarLoopEntryState

+ type StarLoopbackState struct

+ func NewStarLoopbackState() *StarLoopbackState

+ type SyntaxTree interface

+ GetSourceInterval func() *Interval

+ type TerminalNode interface

+ GetSymbol func() Token

+ type TerminalNodeImpl struct

+ func NewTerminalNodeImpl(symbol Token) *TerminalNodeImpl

+ func (t *TerminalNodeImpl) Accept(v ParseTreeVisitor) interface{}

+ func (t *TerminalNodeImpl) GetChild(i int) Tree

+ func (t *TerminalNodeImpl) GetChildCount() int

+ func (t *TerminalNodeImpl) GetChildren() []Tree

+ func (t *TerminalNodeImpl) GetParent() Tree

+ func (t *TerminalNodeImpl) GetPayload() interface{}

+ func (t *TerminalNodeImpl) GetSourceInterval() *Interval

+ func (t *TerminalNodeImpl) GetSymbol() Token

+ func (t *TerminalNodeImpl) GetText() string

+ func (t *TerminalNodeImpl) SetChildren(tree []Tree)

+ func (t *TerminalNodeImpl) SetParent(tree Tree)

+ func (t *TerminalNodeImpl) String() string

+ func (t *TerminalNodeImpl) ToStringTree(s []string, r Recognizer) string

+ type Token interface

+ GetChannel func() int

+ GetColumn func() int

+ GetInputStream func() CharStream

+ GetLine func() int

+ GetSource func() *TokenSourceCharStreamPair

+ GetStart func() int

+ GetStop func() int

+ GetText func() string

+ GetTokenIndex func() int

+ GetTokenSource func() TokenSource

+ GetTokenType func() int

+ SetText func(s string)

+ SetTokenIndex func(v int)

+ type TokenFactory interface

+ Create func(source *TokenSourceCharStreamPair, ttype int, text string, ...) Token

+ type TokenSource interface

+ GetCharPositionInLine func() int

+ GetInputStream func() CharStream

+ GetLine func() int

+ GetSourceName func() string

+ GetTokenFactory func() TokenFactory

+ More func()

+ NextToken func() Token

+ Skip func()

+ type TokenSourceCharStreamPair struct

+ type TokenStream interface

+ Get func(index int) Token

+ GetAllText func() string

+ GetTextFromInterval func(*Interval) string

+ GetTextFromRuleContext func(RuleContext) string

+ GetTextFromTokens func(Token, Token) string

+ GetTokenSource func() TokenSource

+ LT func(k int) Token

+ SetTokenSource func(TokenSource)

+ type TokenStreamRewriter struct

+ func NewTokenStreamRewriter(tokens TokenStream) *TokenStreamRewriter

+ func (tsr *TokenStreamRewriter) AddToProgram(name string, op RewriteOperation)

+ func (tsr *TokenStreamRewriter) Delete(program_name string, from, to int)

+ func (tsr *TokenStreamRewriter) DeleteDefault(from, to int)

+ func (tsr *TokenStreamRewriter) DeleteDefaultPos(index int)

+ func (tsr *TokenStreamRewriter) DeleteProgram(program_name string)

+ func (tsr *TokenStreamRewriter) DeleteProgramDefault()

+ func (tsr *TokenStreamRewriter) DeleteToken(program_name string, from, to Token)

+ func (tsr *TokenStreamRewriter) DeleteTokenDefault(from, to Token)

+ func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndex(program_name string) int

+ func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndexDefault() int

+ func (tsr *TokenStreamRewriter) GetProgram(name string) []RewriteOperation

+ func (tsr *TokenStreamRewriter) GetText(program_name string, interval *Interval) string

+ func (tsr *TokenStreamRewriter) GetTextDefault() string

+ func (tsr *TokenStreamRewriter) GetTokenStream() TokenStream

+ func (tsr *TokenStreamRewriter) InitializeProgram(name string) []RewriteOperation

+ func (tsr *TokenStreamRewriter) InsertAfter(program_name string, index int, text string)

+ func (tsr *TokenStreamRewriter) InsertAfterDefault(index int, text string)

+ func (tsr *TokenStreamRewriter) InsertAfterToken(program_name string, token Token, text string)

+ func (tsr *TokenStreamRewriter) InsertBefore(program_name string, index int, text string)

+ func (tsr *TokenStreamRewriter) InsertBeforeDefault(index int, text string)

+ func (tsr *TokenStreamRewriter) InsertBeforeToken(program_name string, token Token, text string)

+ func (tsr *TokenStreamRewriter) Replace(program_name string, from, to int, text string)

+ func (tsr *TokenStreamRewriter) ReplaceDefault(from, to int, text string)

+ func (tsr *TokenStreamRewriter) ReplaceDefaultPos(index int, text string)

+ func (tsr *TokenStreamRewriter) ReplaceToken(program_name string, from, to Token, text string)

+ func (tsr *TokenStreamRewriter) ReplaceTokenDefault(from, to Token, text string)

+ func (tsr *TokenStreamRewriter) ReplaceTokenDefaultPos(index Token, text string)

+ func (tsr *TokenStreamRewriter) Rollback(program_name string, instruction_index int)

+ func (tsr *TokenStreamRewriter) RollbackDefault(instruction_index int)

+ func (tsr *TokenStreamRewriter) SetLastRewriteTokenIndex(program_name string, i int)

+ type TokensStartState struct

+ func NewTokensStartState() *TokensStartState

+ type TraceListener struct

+ func NewTraceListener(parser *BaseParser) *TraceListener

+ func (t *TraceListener) EnterEveryRule(ctx ParserRuleContext)

+ func (t *TraceListener) ExitEveryRule(ctx ParserRuleContext)

+ func (t *TraceListener) VisitErrorNode(_ ErrorNode)

+ func (t *TraceListener) VisitTerminal(node TerminalNode)

+ type Transition interface

+ Matches func(int, int, int) bool

+ type Tree interface

+ GetChild func(i int) Tree

+ GetChildCount func() int

+ GetChildren func() []Tree

+ GetParent func() Tree

+ GetPayload func() interface{}

+ SetParent func(Tree)

+ func TreesGetChildren(t Tree) []Tree

+ func TreesgetAncestors(t Tree) []Tree

+ type WildcardTransition struct

+ func NewWildcardTransition(target ATNState) *WildcardTransition

+ func (t *WildcardTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

+ func (t *WildcardTransition) String() string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL