parser

package

Go to main page

Versions in this module

v0

v0.4.17

Feb 21, 2023

v0.4.16

Sep 16, 2022

v0.4.15

Jul 25, 2022

v0.4.14

Jul 25, 2022

v0.4.13

May 5, 2021

v0.4.12

May 5, 2021

v0.4.11

Aug 14, 2020

v0.4.10

Aug 14, 2020

v0.4.9

Aug 14, 2020

v0.4.8

Aug 14, 2020

v0.4.7

Aug 6, 2020

v0.4.6

Apr 25, 2020

v0.4.5

Feb 16, 2020

v0.4.4

Oct 26, 2019

v0.4.3

Sep 29, 2019

v0.4.2

Sep 17, 2019

v0.4.0

Sep 7, 2019

Changes in this version

type LDELexer

+ func (l *LDELexer) Action(localctx antlr.RuleContext, ruleIndex, actionIndex int)

+ func (l *LDELexer) Comments() map[int]map[int]string

+ func (l *LDELexer) LineComment_Action(localctx antlr.RuleContext, actionIndex int)

v0.3.6

Sep 7, 2019

v0.3.5

Sep 4, 2019

v0.3.4

Jul 30, 2019

v0.3.3

Jul 22, 2019

v0.3.2

Jul 21, 2019

v0.3.1

Jul 21, 2019

v0.3.0

Jul 20, 2019

v0.2.0

Jul 20, 2019

v0.1.1

Jul 21, 2019

Changes in this version

+ const LDELexerDollarIdentifier

+ const LDELexerT__18

+ const LDEParserDollarIdentifier

+ const LDEParserRULE_optionalNamedSilentArea

+ const LDEParserT__18

type AtomicActionContext

+ func (s *AtomicActionContext) OptionalNamedSilentArea() IOptionalNamedSilentAreaContext

type BaseLDEListener

+ func (s *BaseLDEListener) EnterOptionalNamedSilentArea(ctx *OptionalNamedSilentAreaContext)

+ func (s *BaseLDEListener) ExitOptionalNamedSilentArea(ctx *OptionalNamedSilentAreaContext)

type FieldTypeContext

+ func (s *FieldTypeContext) DollarIdentifier() antlr.TerminalNode

+ type IOptionalNamedSilentAreaContext interface

+ GetParser func() antlr.Parser

+ IsOptionalNamedSilentAreaContext func()

type LDEListener

+ EnterOptionalNamedSilentArea func(c *OptionalNamedSilentAreaContext)

+ ExitOptionalNamedSilentArea func(c *OptionalNamedSilentAreaContext)

type LDEParser

+ func (p *LDEParser) OptionalNamedSilentArea() (localctx IOptionalNamedSilentAreaContext)

+ type OptionalNamedSilentAreaContext struct

+ func NewEmptyOptionalNamedSilentAreaContext() *OptionalNamedSilentAreaContext

+ func NewOptionalNamedSilentAreaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionalNamedSilentAreaContext

+ func (*OptionalNamedSilentAreaContext) IsOptionalNamedSilentAreaContext()

+ func (s *OptionalNamedSilentAreaContext) BaseAction() IBaseActionContext

+ func (s *OptionalNamedSilentAreaContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *OptionalNamedSilentAreaContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *OptionalNamedSilentAreaContext) GetParser() antlr.Parser

+ func (s *OptionalNamedSilentAreaContext) GetRuleContext() antlr.RuleContext

+ func (s *OptionalNamedSilentAreaContext) Identifier() antlr.TerminalNode

+ func (s *OptionalNamedSilentAreaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TypeDeclarationContext

+ func (s *TypeDeclarationContext) Identifier() antlr.TerminalNode

v0.1.0

Jul 20, 2019

Changes in this version

+ const LDELexerIdentifierMayStar

+ const LDELexerT__16

+ const LDELexerT__17

+ const LDELexerTypeName

+ const LDEParserIdentifierMayStar

+ const LDEParserRULE_typeDeclaration

+ const LDEParserT__16

+ const LDEParserT__17

+ const LDEParserTypeName

type BaseLDEListener

+ func (s *BaseLDEListener) EnterTypeDeclaration(ctx *TypeDeclarationContext)

+ func (s *BaseLDEListener) ExitTypeDeclaration(ctx *TypeDeclarationContext)

type FieldTypeContext

+ func (s *FieldTypeContext) TypeName() antlr.TerminalNode

+ type ITypeDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsTypeDeclarationContext func()

type LDEListener

+ EnterTypeDeclaration func(c *TypeDeclarationContext)

+ ExitTypeDeclaration func(c *TypeDeclarationContext)

type LDEParser

+ func (p *LDEParser) TypeDeclaration() (localctx ITypeDeclarationContext)

type RulesContext

+ func (s *RulesContext) AllTypeDeclaration() []ITypeDeclarationContext

+ func (s *RulesContext) TypeDeclaration(i int) ITypeDeclarationContext

+ type TypeDeclarationContext struct

+ func NewEmptyTypeDeclarationContext() *TypeDeclarationContext

+ func NewTypeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeDeclarationContext

+ func (*TypeDeclarationContext) IsTypeDeclarationContext()

+ func (s *TypeDeclarationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TypeDeclarationContext) GetParser() antlr.Parser

+ func (s *TypeDeclarationContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeDeclarationContext) IdentifierMayStar() antlr.TerminalNode

+ func (s *TypeDeclarationContext) StringLit() antlr.TerminalNode

+ func (s *TypeDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TypeDeclarationContext) TypeName() antlr.TerminalNode

v0.0.7

Jul 17, 2019

v0.0.6

Jul 17, 2019

v0.0.5

Jul 16, 2019

Changes in this version

type RulesContext

+ func (s *RulesContext) AllAtomicRule() []IAtomicRuleContext

v0.0.4

May 22, 2019

v0.0.3

May 14, 2019

v0.0.2

Mar 22, 2019

v0.0.1

Mar 17, 2019

Changes in this version

+ const LDELexerCharLit

+ const LDELexerComparisonOperator

+ const LDELexerIdentifier

+ const LDELexerIdentifierWithFraction

+ const LDELexerIntLit

+ const LDELexerLineComment

+ const LDELexerStress

+ const LDELexerStringLit

+ const LDELexerT__0

+ const LDELexerT__1

+ const LDELexerT__10

+ const LDELexerT__11

+ const LDELexerT__12

+ const LDELexerT__13

+ const LDELexerT__14

+ const LDELexerT__15

+ const LDELexerT__2

+ const LDELexerT__3

+ const LDELexerT__4

+ const LDELexerT__5

+ const LDELexerT__6

+ const LDELexerT__7

+ const LDELexerT__8

+ const LDELexerT__9

+ const LDELexerWS

+ const LDEParserCharLit

+ const LDEParserComparisonOperator

+ const LDEParserEOF

+ const LDEParserIdentifier

+ const LDEParserIdentifierWithFraction

+ const LDEParserIntLit

+ const LDEParserLineComment

+ const LDEParserRULE_atEnd

+ const LDEParserRULE_atomicAction

+ const LDEParserRULE_atomicRule

+ const LDEParserRULE_baseAction

+ const LDEParserRULE_bound

+ const LDEParserRULE_checkTargetPrefix

+ const LDEParserRULE_exact

+ const LDEParserRULE_fieldType

+ const LDEParserRULE_goUntil

+ const LDEParserRULE_jump

+ const LDEParserRULE_limit

+ const LDEParserRULE_mayBePassTargetPrefix

+ const LDEParserRULE_mayGoUntil

+ const LDEParserRULE_mayPassUntil

+ const LDEParserRULE_optionalArea

+ const LDEParserRULE_optionalNamedArea

+ const LDEParserRULE_passChars

+ const LDEParserRULE_passHeadingCharacters

+ const LDEParserRULE_passTargetPrefix

+ const LDEParserRULE_passUntil

+ const LDEParserRULE_restCheck

+ const LDEParserRULE_rules

+ const LDEParserRULE_takeUntil

+ const LDEParserRULE_takeUntilIncluding

+ const LDEParserRULE_takeUntilIncludingOrRest

+ const LDEParserRULE_takeUntilOrRest

+ const LDEParserRULE_takeUntilRest

+ const LDEParserRULE_target

+ const LDEParserRULE_targetLit

+ const LDEParserStress

+ const LDEParserStringLit

+ const LDEParserT__0

+ const LDEParserT__1

+ const LDEParserT__10

+ const LDEParserT__11

+ const LDEParserT__12

+ const LDEParserT__13

+ const LDEParserT__14

+ const LDEParserT__15

+ const LDEParserT__2

+ const LDEParserT__3

+ const LDEParserT__4

+ const LDEParserT__5

+ const LDEParserT__6

+ const LDEParserT__7

+ const LDEParserT__8

+ const LDEParserT__9

+ const LDEParserWS

+ type AtEndContext struct

+ func NewAtEndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtEndContext

+ func NewEmptyAtEndContext() *AtEndContext

+ func (*AtEndContext) IsAtEndContext()

+ func (s *AtEndContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtEndContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtEndContext) GetParser() antlr.Parser

+ func (s *AtEndContext) GetRuleContext() antlr.RuleContext

+ func (s *AtEndContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AtomicActionContext struct

+ func NewAtomicActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomicActionContext

+ func NewEmptyAtomicActionContext() *AtomicActionContext

+ func (*AtomicActionContext) IsAtomicActionContext()

+ func (s *AtomicActionContext) AtEnd() IAtEndContext

+ func (s *AtomicActionContext) CheckTargetPrefix() ICheckTargetPrefixContext

+ func (s *AtomicActionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomicActionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomicActionContext) GetParser() antlr.Parser

+ func (s *AtomicActionContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomicActionContext) GoUntil() IGoUntilContext

+ func (s *AtomicActionContext) MayBePassTargetPrefix() IMayBePassTargetPrefixContext

+ func (s *AtomicActionContext) MayGoUntil() IMayGoUntilContext

+ func (s *AtomicActionContext) MayPassUntil() IMayPassUntilContext

+ func (s *AtomicActionContext) OptionalArea() IOptionalAreaContext

+ func (s *AtomicActionContext) OptionalNamedArea() IOptionalNamedAreaContext

+ func (s *AtomicActionContext) PassChars() IPassCharsContext

+ func (s *AtomicActionContext) PassHeadingCharacters() IPassHeadingCharactersContext

+ func (s *AtomicActionContext) PassTargetPrefix() IPassTargetPrefixContext

+ func (s *AtomicActionContext) PassUntil() IPassUntilContext

+ func (s *AtomicActionContext) RestCheck() IRestCheckContext

+ func (s *AtomicActionContext) TakeUntil() ITakeUntilContext

+ func (s *AtomicActionContext) TakeUntilIncluding() ITakeUntilIncludingContext

+ func (s *AtomicActionContext) TakeUntilIncludingOrRest() ITakeUntilIncludingOrRestContext

+ func (s *AtomicActionContext) TakeUntilOrRest() ITakeUntilOrRestContext

+ func (s *AtomicActionContext) TakeUntilRest() ITakeUntilRestContext

+ func (s *AtomicActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AtomicRuleContext struct

+ func NewAtomicRuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomicRuleContext

+ func NewEmptyAtomicRuleContext() *AtomicRuleContext

+ func (*AtomicRuleContext) IsAtomicRuleContext()

+ func (s *AtomicRuleContext) BaseAction() IBaseActionContext

+ func (s *AtomicRuleContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomicRuleContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomicRuleContext) GetParser() antlr.Parser

+ func (s *AtomicRuleContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomicRuleContext) Identifier() antlr.TerminalNode

+ func (s *AtomicRuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BaseActionContext struct

+ func NewBaseActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BaseActionContext

+ func NewEmptyBaseActionContext() *BaseActionContext

+ func (*BaseActionContext) IsBaseActionContext()

+ func (s *BaseActionContext) AllBaseAction() []IBaseActionContext

+ func (s *BaseActionContext) AtomicAction() IAtomicActionContext

+ func (s *BaseActionContext) BaseAction(i int) IBaseActionContext

+ func (s *BaseActionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *BaseActionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *BaseActionContext) GetParser() antlr.Parser

+ func (s *BaseActionContext) GetRuleContext() antlr.RuleContext

+ func (s *BaseActionContext) Stress() antlr.TerminalNode

+ func (s *BaseActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BaseLDEListener struct

+ func (s *BaseLDEListener) EnterAtEnd(ctx *AtEndContext)

+ func (s *BaseLDEListener) EnterAtomicAction(ctx *AtomicActionContext)

+ func (s *BaseLDEListener) EnterAtomicRule(ctx *AtomicRuleContext)

+ func (s *BaseLDEListener) EnterBaseAction(ctx *BaseActionContext)

+ func (s *BaseLDEListener) EnterBound(ctx *BoundContext)

+ func (s *BaseLDEListener) EnterCheckTargetPrefix(ctx *CheckTargetPrefixContext)

+ func (s *BaseLDEListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseLDEListener) EnterExact(ctx *ExactContext)

+ func (s *BaseLDEListener) EnterFieldType(ctx *FieldTypeContext)

+ func (s *BaseLDEListener) EnterGoUntil(ctx *GoUntilContext)

+ func (s *BaseLDEListener) EnterJump(ctx *JumpContext)

+ func (s *BaseLDEListener) EnterLimit(ctx *LimitContext)

+ func (s *BaseLDEListener) EnterMayBePassTargetPrefix(ctx *MayBePassTargetPrefixContext)

+ func (s *BaseLDEListener) EnterMayGoUntil(ctx *MayGoUntilContext)

+ func (s *BaseLDEListener) EnterMayPassUntil(ctx *MayPassUntilContext)

+ func (s *BaseLDEListener) EnterOptionalArea(ctx *OptionalAreaContext)

+ func (s *BaseLDEListener) EnterOptionalNamedArea(ctx *OptionalNamedAreaContext)

+ func (s *BaseLDEListener) EnterPassChars(ctx *PassCharsContext)

+ func (s *BaseLDEListener) EnterPassHeadingCharacters(ctx *PassHeadingCharactersContext)

+ func (s *BaseLDEListener) EnterPassTargetPrefix(ctx *PassTargetPrefixContext)

+ func (s *BaseLDEListener) EnterPassUntil(ctx *PassUntilContext)

+ func (s *BaseLDEListener) EnterRestCheck(ctx *RestCheckContext)

+ func (s *BaseLDEListener) EnterRules(ctx *RulesContext)

+ func (s *BaseLDEListener) EnterTakeUntil(ctx *TakeUntilContext)

+ func (s *BaseLDEListener) EnterTakeUntilIncluding(ctx *TakeUntilIncludingContext)

+ func (s *BaseLDEListener) EnterTakeUntilIncludingOrRest(ctx *TakeUntilIncludingOrRestContext)

+ func (s *BaseLDEListener) EnterTakeUntilOrRest(ctx *TakeUntilOrRestContext)

+ func (s *BaseLDEListener) EnterTakeUntilRest(ctx *TakeUntilRestContext)

+ func (s *BaseLDEListener) EnterTarget(ctx *TargetContext)

+ func (s *BaseLDEListener) EnterTargetLit(ctx *TargetLitContext)

+ func (s *BaseLDEListener) ExitAtEnd(ctx *AtEndContext)

+ func (s *BaseLDEListener) ExitAtomicAction(ctx *AtomicActionContext)

+ func (s *BaseLDEListener) ExitAtomicRule(ctx *AtomicRuleContext)

+ func (s *BaseLDEListener) ExitBaseAction(ctx *BaseActionContext)

+ func (s *BaseLDEListener) ExitBound(ctx *BoundContext)

+ func (s *BaseLDEListener) ExitCheckTargetPrefix(ctx *CheckTargetPrefixContext)

+ func (s *BaseLDEListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseLDEListener) ExitExact(ctx *ExactContext)

+ func (s *BaseLDEListener) ExitFieldType(ctx *FieldTypeContext)

+ func (s *BaseLDEListener) ExitGoUntil(ctx *GoUntilContext)

+ func (s *BaseLDEListener) ExitJump(ctx *JumpContext)

+ func (s *BaseLDEListener) ExitLimit(ctx *LimitContext)

+ func (s *BaseLDEListener) ExitMayBePassTargetPrefix(ctx *MayBePassTargetPrefixContext)

+ func (s *BaseLDEListener) ExitMayGoUntil(ctx *MayGoUntilContext)

+ func (s *BaseLDEListener) ExitMayPassUntil(ctx *MayPassUntilContext)

+ func (s *BaseLDEListener) ExitOptionalArea(ctx *OptionalAreaContext)

+ func (s *BaseLDEListener) ExitOptionalNamedArea(ctx *OptionalNamedAreaContext)

+ func (s *BaseLDEListener) ExitPassChars(ctx *PassCharsContext)

+ func (s *BaseLDEListener) ExitPassHeadingCharacters(ctx *PassHeadingCharactersContext)

+ func (s *BaseLDEListener) ExitPassTargetPrefix(ctx *PassTargetPrefixContext)

+ func (s *BaseLDEListener) ExitPassUntil(ctx *PassUntilContext)

+ func (s *BaseLDEListener) ExitRestCheck(ctx *RestCheckContext)

+ func (s *BaseLDEListener) ExitRules(ctx *RulesContext)

+ func (s *BaseLDEListener) ExitTakeUntil(ctx *TakeUntilContext)

+ func (s *BaseLDEListener) ExitTakeUntilIncluding(ctx *TakeUntilIncludingContext)

+ func (s *BaseLDEListener) ExitTakeUntilIncludingOrRest(ctx *TakeUntilIncludingOrRestContext)

+ func (s *BaseLDEListener) ExitTakeUntilOrRest(ctx *TakeUntilOrRestContext)

+ func (s *BaseLDEListener) ExitTakeUntilRest(ctx *TakeUntilRestContext)

+ func (s *BaseLDEListener) ExitTarget(ctx *TargetContext)

+ func (s *BaseLDEListener) ExitTargetLit(ctx *TargetLitContext)

+ func (s *BaseLDEListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseLDEListener) VisitTerminal(node antlr.TerminalNode)

+ type BoundContext struct

+ func NewBoundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoundContext

+ func NewEmptyBoundContext() *BoundContext

+ func (*BoundContext) IsBoundContext()

+ func (s *BoundContext) AllIntLit() []antlr.TerminalNode

+ func (s *BoundContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *BoundContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *BoundContext) GetParser() antlr.Parser

+ func (s *BoundContext) GetRuleContext() antlr.RuleContext

+ func (s *BoundContext) IntLit(i int) antlr.TerminalNode

+ func (s *BoundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type CheckTargetPrefixContext struct

+ func NewCheckTargetPrefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckTargetPrefixContext

+ func NewEmptyCheckTargetPrefixContext() *CheckTargetPrefixContext

+ func (*CheckTargetPrefixContext) IsCheckTargetPrefixContext()

+ func (s *CheckTargetPrefixContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *CheckTargetPrefixContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *CheckTargetPrefixContext) GetParser() antlr.Parser

+ func (s *CheckTargetPrefixContext) GetRuleContext() antlr.RuleContext

+ func (s *CheckTargetPrefixContext) IntLit() antlr.TerminalNode

+ func (s *CheckTargetPrefixContext) TargetLit() ITargetLitContext

+ func (s *CheckTargetPrefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ExactContext struct

+ func NewEmptyExactContext() *ExactContext

+ func NewExactContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExactContext

+ func (*ExactContext) IsExactContext()

+ func (s *ExactContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ExactContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ExactContext) GetParser() antlr.Parser

+ func (s *ExactContext) GetRuleContext() antlr.RuleContext

+ func (s *ExactContext) IntLit() antlr.TerminalNode

+ func (s *ExactContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type FieldTypeContext struct

+ func NewEmptyFieldTypeContext() *FieldTypeContext

+ func NewFieldTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldTypeContext

+ func (*FieldTypeContext) IsFieldTypeContext()

+ func (s *FieldTypeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FieldTypeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FieldTypeContext) GetParser() antlr.Parser

+ func (s *FieldTypeContext) GetRuleContext() antlr.RuleContext

+ func (s *FieldTypeContext) Identifier() antlr.TerminalNode

+ func (s *FieldTypeContext) IdentifierWithFraction() antlr.TerminalNode

+ func (s *FieldTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type GoUntilContext struct

+ func NewEmptyGoUntilContext() *GoUntilContext

+ func NewGoUntilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GoUntilContext

+ func (*GoUntilContext) IsGoUntilContext()

+ func (s *GoUntilContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *GoUntilContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *GoUntilContext) GetParser() antlr.Parser

+ func (s *GoUntilContext) GetRuleContext() antlr.RuleContext

+ func (s *GoUntilContext) Target() ITargetContext

+ func (s *GoUntilContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IAtEndContext interface

+ GetParser func() antlr.Parser

+ IsAtEndContext func()

+ type IAtomicActionContext interface

+ GetParser func() antlr.Parser

+ IsAtomicActionContext func()

+ type IAtomicRuleContext interface

+ GetParser func() antlr.Parser

+ IsAtomicRuleContext func()

+ type IBaseActionContext interface

+ GetParser func() antlr.Parser

+ IsBaseActionContext func()

+ type IBoundContext interface

+ GetParser func() antlr.Parser

+ IsBoundContext func()

+ type ICheckTargetPrefixContext interface

+ GetParser func() antlr.Parser

+ IsCheckTargetPrefixContext func()

+ type IExactContext interface

+ GetParser func() antlr.Parser

+ IsExactContext func()

+ type IFieldTypeContext interface

+ GetParser func() antlr.Parser

+ IsFieldTypeContext func()

+ type IGoUntilContext interface

+ GetParser func() antlr.Parser

+ IsGoUntilContext func()

+ type IJumpContext interface

+ GetParser func() antlr.Parser

+ IsJumpContext func()

+ type ILimitContext interface

+ GetParser func() antlr.Parser

+ IsLimitContext func()

+ type IMayBePassTargetPrefixContext interface

+ GetParser func() antlr.Parser

+ IsMayBePassTargetPrefixContext func()

+ type IMayGoUntilContext interface

+ GetParser func() antlr.Parser

+ IsMayGoUntilContext func()

+ type IMayPassUntilContext interface

+ GetParser func() antlr.Parser

+ IsMayPassUntilContext func()

+ type IOptionalAreaContext interface

+ GetParser func() antlr.Parser

+ IsOptionalAreaContext func()

+ type IOptionalNamedAreaContext interface

+ GetParser func() antlr.Parser

+ IsOptionalNamedAreaContext func()

+ type IPassCharsContext interface

+ GetParser func() antlr.Parser

+ IsPassCharsContext func()

+ type IPassHeadingCharactersContext interface

+ GetParser func() antlr.Parser

+ IsPassHeadingCharactersContext func()

+ type IPassTargetPrefixContext interface

+ GetParser func() antlr.Parser

+ IsPassTargetPrefixContext func()

+ type IPassUntilContext interface

+ GetParser func() antlr.Parser

+ IsPassUntilContext func()

+ type IRestCheckContext interface

+ GetParser func() antlr.Parser

+ IsRestCheckContext func()

+ type IRulesContext interface

+ GetParser func() antlr.Parser

+ IsRulesContext func()

+ type ITakeUntilContext interface

+ GetParser func() antlr.Parser

+ IsTakeUntilContext func()

+ type ITakeUntilIncludingContext interface

+ GetParser func() antlr.Parser

+ IsTakeUntilIncludingContext func()

+ type ITakeUntilIncludingOrRestContext interface

+ GetParser func() antlr.Parser

+ IsTakeUntilIncludingOrRestContext func()

+ type ITakeUntilOrRestContext interface

+ GetParser func() antlr.Parser

+ IsTakeUntilOrRestContext func()

+ type ITakeUntilRestContext interface

+ GetParser func() antlr.Parser

+ IsTakeUntilRestContext func()

+ type ITargetContext interface

+ GetParser func() antlr.Parser

+ IsTargetContext func()

+ type ITargetLitContext interface

+ GetParser func() antlr.Parser

+ IsTargetLitContext func()

+ type JumpContext struct

+ func NewEmptyJumpContext() *JumpContext

+ func NewJumpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JumpContext

+ func (*JumpContext) IsJumpContext()

+ func (s *JumpContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *JumpContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *JumpContext) GetParser() antlr.Parser

+ func (s *JumpContext) GetRuleContext() antlr.RuleContext

+ func (s *JumpContext) IntLit() antlr.TerminalNode

+ func (s *JumpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type LDELexer struct

+ func NewLDELexer(input antlr.CharStream) *LDELexer

+ type LDEListener interface

+ EnterAtEnd func(c *AtEndContext)

+ EnterAtomicAction func(c *AtomicActionContext)

+ EnterAtomicRule func(c *AtomicRuleContext)

+ EnterBaseAction func(c *BaseActionContext)

+ EnterBound func(c *BoundContext)

+ EnterCheckTargetPrefix func(c *CheckTargetPrefixContext)

+ EnterExact func(c *ExactContext)

+ EnterFieldType func(c *FieldTypeContext)

+ EnterGoUntil func(c *GoUntilContext)

+ EnterJump func(c *JumpContext)

+ EnterLimit func(c *LimitContext)

+ EnterMayBePassTargetPrefix func(c *MayBePassTargetPrefixContext)

+ EnterMayGoUntil func(c *MayGoUntilContext)

+ EnterMayPassUntil func(c *MayPassUntilContext)

+ EnterOptionalArea func(c *OptionalAreaContext)

+ EnterOptionalNamedArea func(c *OptionalNamedAreaContext)

+ EnterPassChars func(c *PassCharsContext)

+ EnterPassHeadingCharacters func(c *PassHeadingCharactersContext)

+ EnterPassTargetPrefix func(c *PassTargetPrefixContext)

+ EnterPassUntil func(c *PassUntilContext)

+ EnterRestCheck func(c *RestCheckContext)

+ EnterRules func(c *RulesContext)

+ EnterTakeUntil func(c *TakeUntilContext)

+ EnterTakeUntilIncluding func(c *TakeUntilIncludingContext)

+ EnterTakeUntilIncludingOrRest func(c *TakeUntilIncludingOrRestContext)

+ EnterTakeUntilOrRest func(c *TakeUntilOrRestContext)

+ EnterTakeUntilRest func(c *TakeUntilRestContext)

+ EnterTarget func(c *TargetContext)

+ EnterTargetLit func(c *TargetLitContext)

+ ExitAtEnd func(c *AtEndContext)

+ ExitAtomicAction func(c *AtomicActionContext)

+ ExitAtomicRule func(c *AtomicRuleContext)

+ ExitBaseAction func(c *BaseActionContext)

+ ExitBound func(c *BoundContext)

+ ExitCheckTargetPrefix func(c *CheckTargetPrefixContext)

+ ExitExact func(c *ExactContext)

+ ExitFieldType func(c *FieldTypeContext)

+ ExitGoUntil func(c *GoUntilContext)

+ ExitJump func(c *JumpContext)

+ ExitLimit func(c *LimitContext)

+ ExitMayBePassTargetPrefix func(c *MayBePassTargetPrefixContext)

+ ExitMayGoUntil func(c *MayGoUntilContext)

+ ExitMayPassUntil func(c *MayPassUntilContext)

+ ExitOptionalArea func(c *OptionalAreaContext)

+ ExitOptionalNamedArea func(c *OptionalNamedAreaContext)

+ ExitPassChars func(c *PassCharsContext)

+ ExitPassHeadingCharacters func(c *PassHeadingCharactersContext)

+ ExitPassTargetPrefix func(c *PassTargetPrefixContext)

+ ExitPassUntil func(c *PassUntilContext)

+ ExitRestCheck func(c *RestCheckContext)

+ ExitRules func(c *RulesContext)

+ ExitTakeUntil func(c *TakeUntilContext)

+ ExitTakeUntilIncluding func(c *TakeUntilIncludingContext)

+ ExitTakeUntilIncludingOrRest func(c *TakeUntilIncludingOrRestContext)

+ ExitTakeUntilOrRest func(c *TakeUntilOrRestContext)

+ ExitTakeUntilRest func(c *TakeUntilRestContext)

+ ExitTarget func(c *TargetContext)

+ ExitTargetLit func(c *TargetLitContext)

+ type LDEParser struct

+ func NewLDEParser(input antlr.TokenStream) *LDEParser

+ func (p *LDEParser) AtEnd() (localctx IAtEndContext)

+ func (p *LDEParser) AtomicAction() (localctx IAtomicActionContext)

+ func (p *LDEParser) AtomicRule() (localctx IAtomicRuleContext)

+ func (p *LDEParser) BaseAction() (localctx IBaseActionContext)

+ func (p *LDEParser) Bound() (localctx IBoundContext)

+ func (p *LDEParser) CheckTargetPrefix() (localctx ICheckTargetPrefixContext)

+ func (p *LDEParser) Exact() (localctx IExactContext)

+ func (p *LDEParser) FieldType() (localctx IFieldTypeContext)

+ func (p *LDEParser) GoUntil() (localctx IGoUntilContext)

+ func (p *LDEParser) Jump() (localctx IJumpContext)

+ func (p *LDEParser) Limit() (localctx ILimitContext)

+ func (p *LDEParser) MayBePassTargetPrefix() (localctx IMayBePassTargetPrefixContext)

+ func (p *LDEParser) MayGoUntil() (localctx IMayGoUntilContext)

+ func (p *LDEParser) MayPassUntil() (localctx IMayPassUntilContext)

+ func (p *LDEParser) OptionalArea() (localctx IOptionalAreaContext)

+ func (p *LDEParser) OptionalNamedArea() (localctx IOptionalNamedAreaContext)

+ func (p *LDEParser) PassChars() (localctx IPassCharsContext)

+ func (p *LDEParser) PassHeadingCharacters() (localctx IPassHeadingCharactersContext)

+ func (p *LDEParser) PassTargetPrefix() (localctx IPassTargetPrefixContext)

+ func (p *LDEParser) PassUntil() (localctx IPassUntilContext)

+ func (p *LDEParser) RestCheck() (localctx IRestCheckContext)

+ func (p *LDEParser) Rules() (localctx IRulesContext)

+ func (p *LDEParser) Rules_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *LDEParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *LDEParser) TakeUntil() (localctx ITakeUntilContext)

+ func (p *LDEParser) TakeUntilIncluding() (localctx ITakeUntilIncludingContext)

+ func (p *LDEParser) TakeUntilIncludingOrRest() (localctx ITakeUntilIncludingOrRestContext)

+ func (p *LDEParser) TakeUntilOrRest() (localctx ITakeUntilOrRestContext)

+ func (p *LDEParser) TakeUntilRest() (localctx ITakeUntilRestContext)

+ func (p *LDEParser) Target() (localctx ITargetContext)

+ func (p *LDEParser) TargetLit() (localctx ITargetLitContext)

+ type LimitContext struct

+ func NewEmptyLimitContext() *LimitContext

+ func NewLimitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitContext

+ func (*LimitContext) IsLimitContext()

+ func (s *LimitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LimitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LimitContext) GetParser() antlr.Parser

+ func (s *LimitContext) GetRuleContext() antlr.RuleContext

+ func (s *LimitContext) IntLit() antlr.TerminalNode

+ func (s *LimitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MayBePassTargetPrefixContext struct

+ func NewEmptyMayBePassTargetPrefixContext() *MayBePassTargetPrefixContext

+ func NewMayBePassTargetPrefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MayBePassTargetPrefixContext

+ func (*MayBePassTargetPrefixContext) IsMayBePassTargetPrefixContext()

+ func (s *MayBePassTargetPrefixContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MayBePassTargetPrefixContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MayBePassTargetPrefixContext) GetParser() antlr.Parser

+ func (s *MayBePassTargetPrefixContext) GetRuleContext() antlr.RuleContext

+ func (s *MayBePassTargetPrefixContext) IntLit() antlr.TerminalNode

+ func (s *MayBePassTargetPrefixContext) TargetLit() ITargetLitContext

+ func (s *MayBePassTargetPrefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MayGoUntilContext struct

+ func NewEmptyMayGoUntilContext() *MayGoUntilContext

+ func NewMayGoUntilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MayGoUntilContext

+ func (*MayGoUntilContext) IsMayGoUntilContext()

+ func (s *MayGoUntilContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MayGoUntilContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MayGoUntilContext) GetParser() antlr.Parser

+ func (s *MayGoUntilContext) GetRuleContext() antlr.RuleContext

+ func (s *MayGoUntilContext) Target() ITargetContext

+ func (s *MayGoUntilContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MayPassUntilContext struct

+ func NewEmptyMayPassUntilContext() *MayPassUntilContext

+ func NewMayPassUntilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MayPassUntilContext

+ func (*MayPassUntilContext) IsMayPassUntilContext()

+ func (s *MayPassUntilContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MayPassUntilContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MayPassUntilContext) GetParser() antlr.Parser

+ func (s *MayPassUntilContext) GetRuleContext() antlr.RuleContext

+ func (s *MayPassUntilContext) Target() ITargetContext

+ func (s *MayPassUntilContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type OptionalAreaContext struct

+ func NewEmptyOptionalAreaContext() *OptionalAreaContext

+ func NewOptionalAreaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionalAreaContext

+ func (*OptionalAreaContext) IsOptionalAreaContext()

+ func (s *OptionalAreaContext) BaseAction() IBaseActionContext

+ func (s *OptionalAreaContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *OptionalAreaContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *OptionalAreaContext) GetParser() antlr.Parser

+ func (s *OptionalAreaContext) GetRuleContext() antlr.RuleContext

+ func (s *OptionalAreaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type OptionalNamedAreaContext struct

+ func NewEmptyOptionalNamedAreaContext() *OptionalNamedAreaContext

+ func NewOptionalNamedAreaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionalNamedAreaContext

+ func (*OptionalNamedAreaContext) IsOptionalNamedAreaContext()

+ func (s *OptionalNamedAreaContext) BaseAction() IBaseActionContext

+ func (s *OptionalNamedAreaContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *OptionalNamedAreaContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *OptionalNamedAreaContext) GetParser() antlr.Parser

+ func (s *OptionalNamedAreaContext) GetRuleContext() antlr.RuleContext

+ func (s *OptionalNamedAreaContext) Identifier() antlr.TerminalNode

+ func (s *OptionalNamedAreaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PassCharsContext struct

+ func NewEmptyPassCharsContext() *PassCharsContext

+ func NewPassCharsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PassCharsContext

+ func (*PassCharsContext) IsPassCharsContext()

+ func (s *PassCharsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PassCharsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PassCharsContext) GetParser() antlr.Parser

+ func (s *PassCharsContext) GetRuleContext() antlr.RuleContext

+ func (s *PassCharsContext) IntLit() antlr.TerminalNode

+ func (s *PassCharsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PassHeadingCharactersContext struct

+ func NewEmptyPassHeadingCharactersContext() *PassHeadingCharactersContext

+ func NewPassHeadingCharactersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PassHeadingCharactersContext

+ func (*PassHeadingCharactersContext) IsPassHeadingCharactersContext()

+ func (s *PassHeadingCharactersContext) CharLit() antlr.TerminalNode

+ func (s *PassHeadingCharactersContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PassHeadingCharactersContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PassHeadingCharactersContext) GetParser() antlr.Parser

+ func (s *PassHeadingCharactersContext) GetRuleContext() antlr.RuleContext

+ func (s *PassHeadingCharactersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PassTargetPrefixContext struct

+ func NewEmptyPassTargetPrefixContext() *PassTargetPrefixContext

+ func NewPassTargetPrefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PassTargetPrefixContext

+ func (*PassTargetPrefixContext) IsPassTargetPrefixContext()

+ func (s *PassTargetPrefixContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PassTargetPrefixContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PassTargetPrefixContext) GetParser() antlr.Parser

+ func (s *PassTargetPrefixContext) GetRuleContext() antlr.RuleContext

+ func (s *PassTargetPrefixContext) IntLit() antlr.TerminalNode

+ func (s *PassTargetPrefixContext) TargetLit() ITargetLitContext

+ func (s *PassTargetPrefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PassUntilContext struct

+ func NewEmptyPassUntilContext() *PassUntilContext

+ func NewPassUntilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PassUntilContext

+ func (*PassUntilContext) IsPassUntilContext()

+ func (s *PassUntilContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PassUntilContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PassUntilContext) GetParser() antlr.Parser

+ func (s *PassUntilContext) GetRuleContext() antlr.RuleContext

+ func (s *PassUntilContext) Target() ITargetContext

+ func (s *PassUntilContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RestCheckContext struct

+ func NewEmptyRestCheckContext() *RestCheckContext

+ func NewRestCheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RestCheckContext

+ func (*RestCheckContext) IsRestCheckContext()

+ func (s *RestCheckContext) ComparisonOperator() antlr.TerminalNode

+ func (s *RestCheckContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RestCheckContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RestCheckContext) GetParser() antlr.Parser

+ func (s *RestCheckContext) GetRuleContext() antlr.RuleContext

+ func (s *RestCheckContext) IntLit() antlr.TerminalNode

+ func (s *RestCheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RulesContext struct

+ func NewEmptyRulesContext() *RulesContext

+ func NewRulesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RulesContext

+ func (*RulesContext) IsRulesContext()

+ func (s *RulesContext) AtomicRule() IAtomicRuleContext

+ func (s *RulesContext) EOF() antlr.TerminalNode

+ func (s *RulesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RulesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RulesContext) GetParser() antlr.Parser

+ func (s *RulesContext) GetRuleContext() antlr.RuleContext

+ func (s *RulesContext) Rules() IRulesContext

+ func (s *RulesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TakeUntilContext struct

+ func NewEmptyTakeUntilContext() *TakeUntilContext

+ func NewTakeUntilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TakeUntilContext

+ func (*TakeUntilContext) IsTakeUntilContext()

+ func (s *TakeUntilContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilContext) FieldType() IFieldTypeContext

+ func (s *TakeUntilContext) GetParser() antlr.Parser

+ func (s *TakeUntilContext) GetRuleContext() antlr.RuleContext

+ func (s *TakeUntilContext) Identifier() antlr.TerminalNode

+ func (s *TakeUntilContext) Target() ITargetContext

+ func (s *TakeUntilContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TakeUntilIncludingContext struct

+ func NewEmptyTakeUntilIncludingContext() *TakeUntilIncludingContext

+ func NewTakeUntilIncludingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TakeUntilIncludingContext

+ func (*TakeUntilIncludingContext) IsTakeUntilIncludingContext()

+ func (s *TakeUntilIncludingContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilIncludingContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilIncludingContext) FieldType() IFieldTypeContext

+ func (s *TakeUntilIncludingContext) GetParser() antlr.Parser

+ func (s *TakeUntilIncludingContext) GetRuleContext() antlr.RuleContext

+ func (s *TakeUntilIncludingContext) Identifier() antlr.TerminalNode

+ func (s *TakeUntilIncludingContext) Target() ITargetContext

+ func (s *TakeUntilIncludingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TakeUntilIncludingOrRestContext struct

+ func NewEmptyTakeUntilIncludingOrRestContext() *TakeUntilIncludingOrRestContext

+ func NewTakeUntilIncludingOrRestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TakeUntilIncludingOrRestContext

+ func (*TakeUntilIncludingOrRestContext) IsTakeUntilIncludingOrRestContext()

+ func (s *TakeUntilIncludingOrRestContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilIncludingOrRestContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilIncludingOrRestContext) FieldType() IFieldTypeContext

+ func (s *TakeUntilIncludingOrRestContext) GetParser() antlr.Parser

+ func (s *TakeUntilIncludingOrRestContext) GetRuleContext() antlr.RuleContext

+ func (s *TakeUntilIncludingOrRestContext) Identifier() antlr.TerminalNode

+ func (s *TakeUntilIncludingOrRestContext) Target() ITargetContext

+ func (s *TakeUntilIncludingOrRestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TakeUntilOrRestContext struct

+ func NewEmptyTakeUntilOrRestContext() *TakeUntilOrRestContext

+ func NewTakeUntilOrRestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TakeUntilOrRestContext

+ func (*TakeUntilOrRestContext) IsTakeUntilOrRestContext()

+ func (s *TakeUntilOrRestContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilOrRestContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilOrRestContext) FieldType() IFieldTypeContext

+ func (s *TakeUntilOrRestContext) GetParser() antlr.Parser

+ func (s *TakeUntilOrRestContext) GetRuleContext() antlr.RuleContext

+ func (s *TakeUntilOrRestContext) Identifier() antlr.TerminalNode

+ func (s *TakeUntilOrRestContext) Target() ITargetContext

+ func (s *TakeUntilOrRestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TakeUntilRestContext struct

+ func NewEmptyTakeUntilRestContext() *TakeUntilRestContext

+ func NewTakeUntilRestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TakeUntilRestContext

+ func (*TakeUntilRestContext) IsTakeUntilRestContext()

+ func (s *TakeUntilRestContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilRestContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TakeUntilRestContext) FieldType() IFieldTypeContext

+ func (s *TakeUntilRestContext) GetParser() antlr.Parser

+ func (s *TakeUntilRestContext) GetRuleContext() antlr.RuleContext

+ func (s *TakeUntilRestContext) Identifier() antlr.TerminalNode

+ func (s *TakeUntilRestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TargetContext struct

+ func NewEmptyTargetContext() *TargetContext

+ func NewTargetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TargetContext

+ func (*TargetContext) IsTargetContext()

+ func (s *TargetContext) Bound() IBoundContext

+ func (s *TargetContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TargetContext) Exact() IExactContext

+ func (s *TargetContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TargetContext) GetParser() antlr.Parser

+ func (s *TargetContext) GetRuleContext() antlr.RuleContext

+ func (s *TargetContext) Jump() IJumpContext

+ func (s *TargetContext) Limit() ILimitContext

+ func (s *TargetContext) Target() ITargetContext

+ func (s *TargetContext) TargetLit() ITargetLitContext

+ func (s *TargetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TargetLitContext struct

+ func NewEmptyTargetLitContext() *TargetLitContext

+ func NewTargetLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TargetLitContext

+ func (*TargetLitContext) IsTargetLitContext()

+ func (s *TargetLitContext) CharLit() antlr.TerminalNode

+ func (s *TargetLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TargetLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TargetLitContext) GetParser() antlr.Parser

+ func (s *TargetLitContext) GetRuleContext() antlr.RuleContext

+ func (s *TargetLitContext) StringLit() antlr.TerminalNode

+ func (s *TargetLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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