Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

antlr

package

Go to main page

Versions in this module

v0

v0.5.0

Jun 3, 2024

v0.4.1

Jun 11, 2023

v0.4.0

Jun 7, 2023

Changes in this version

+ const EcaruleLexerALL

+ const EcaruleLexerAND

+ const EcaruleLexerASSIGN

+ const EcaruleLexerBITAND

+ const EcaruleLexerBITOR

+ const EcaruleLexerCOMMENT

+ const EcaruleLexerDECIMAL_EXPONENT

+ const EcaruleLexerDECIMAL_FLOAT_LIT

+ const EcaruleLexerDEC_LIT

+ const EcaruleLexerDEFAULT

+ const EcaruleLexerDIV

+ const EcaruleLexerDIV_ASIGN

+ const EcaruleLexerDO

+ const EcaruleLexerDOT

+ const EcaruleLexerDQUOTA_STRING

+ const EcaruleLexerEQUALS

+ const EcaruleLexerFALSE

+ const EcaruleLexerFOR

+ const EcaruleLexerGT

+ const EcaruleLexerGTE

+ const EcaruleLexerHEX_EXPONENT

+ const EcaruleLexerHEX_FLOAT_LIT

+ const EcaruleLexerHEX_LIT

+ const EcaruleLexerLINE_COMMENT

+ const EcaruleLexerLR_BRACE

+ const EcaruleLexerLR_BRACKET

+ const EcaruleLexerLS_BRACKET

+ const EcaruleLexerLT

+ const EcaruleLexerLTE

+ const EcaruleLexerMINUS

+ const EcaruleLexerMINUS_ASIGN

+ const EcaruleLexerMOD

+ const EcaruleLexerMUL

+ const EcaruleLexerMUL_ASIGN

+ const EcaruleLexerNEGATION

+ const EcaruleLexerNIL_LITERAL

+ const EcaruleLexerNOTEQUALS

+ const EcaruleLexerOCT_LIT

+ const EcaruleLexerON

+ const EcaruleLexerOR

+ const EcaruleLexerPLUS

+ const EcaruleLexerPLUS_ASIGN

+ const EcaruleLexerRR_BRACE

+ const EcaruleLexerRR_BRACKET

+ const EcaruleLexerRS_BRACKET

+ const EcaruleLexerRULE

+ const EcaruleLexerSALIENCE

+ const EcaruleLexerSEMICOLON

+ const EcaruleLexerSIMPLENAME

+ const EcaruleLexerSPACE

+ const EcaruleLexerSQUOTA_STRING

+ const EcaruleLexerTHEN

+ const EcaruleLexerTRUE

+ const EcaruleLexerT__0

+ const EcaruleLexerWHEN

+ const EcaruleParserALL

+ const EcaruleParserAND

+ const EcaruleParserASSIGN

+ const EcaruleParserBITAND

+ const EcaruleParserBITOR

+ const EcaruleParserCOMMENT

+ const EcaruleParserDECIMAL_EXPONENT

+ const EcaruleParserDECIMAL_FLOAT_LIT

+ const EcaruleParserDEC_LIT

+ const EcaruleParserDEFAULT

+ const EcaruleParserDIV

+ const EcaruleParserDIV_ASIGN

+ const EcaruleParserDO

+ const EcaruleParserDOT

+ const EcaruleParserDQUOTA_STRING

+ const EcaruleParserEOF

+ const EcaruleParserEQUALS

+ const EcaruleParserFALSE

+ const EcaruleParserFOR

+ const EcaruleParserGT

+ const EcaruleParserGTE

+ const EcaruleParserHEX_EXPONENT

+ const EcaruleParserHEX_FLOAT_LIT

+ const EcaruleParserHEX_LIT

+ const EcaruleParserLINE_COMMENT

+ const EcaruleParserLR_BRACE

+ const EcaruleParserLR_BRACKET

+ const EcaruleParserLS_BRACKET

+ const EcaruleParserLT

+ const EcaruleParserLTE

+ const EcaruleParserMINUS

+ const EcaruleParserMINUS_ASIGN

+ const EcaruleParserMOD

+ const EcaruleParserMUL

+ const EcaruleParserMUL_ASIGN

+ const EcaruleParserNEGATION

+ const EcaruleParserNIL_LITERAL

+ const EcaruleParserNOTEQUALS

+ const EcaruleParserOCT_LIT

+ const EcaruleParserON

+ const EcaruleParserOR

+ const EcaruleParserPLUS

+ const EcaruleParserPLUS_ASIGN

+ const EcaruleParserRR_BRACE

+ const EcaruleParserRR_BRACKET

+ const EcaruleParserRS_BRACKET

+ const EcaruleParserRULE

+ const EcaruleParserRULE_actions

+ const EcaruleParserRULE_addMinusOperators

+ const EcaruleParserRULE_andLogicOperator

+ const EcaruleParserRULE_argumentList

+ const EcaruleParserRULE_arrayMapSelector

+ const EcaruleParserRULE_assignment

+ const EcaruleParserRULE_booleanLiteral

+ const EcaruleParserRULE_comparisonOperator

+ const EcaruleParserRULE_constant

+ const EcaruleParserRULE_decimalFloatLiteral

+ const EcaruleParserRULE_decimalLiteral

+ const EcaruleParserRULE_defaultActions

+ const EcaruleParserRULE_events

+ const EcaruleParserRULE_expression

+ const EcaruleParserRULE_expressionAtom

+ const EcaruleParserRULE_floatLiteral

+ const EcaruleParserRULE_functionCall

+ const EcaruleParserRULE_grl

+ const EcaruleParserRULE_hexadecimalFloatLiteral

+ const EcaruleParserRULE_hexadecimalLiteral

+ const EcaruleParserRULE_integerLiteral

+ const EcaruleParserRULE_maybeActions

+ const EcaruleParserRULE_memberVariable

+ const EcaruleParserRULE_methodCall

+ const EcaruleParserRULE_mulDivOperators

+ const EcaruleParserRULE_octalLiteral

+ const EcaruleParserRULE_orLogicOperator

+ const EcaruleParserRULE_prule

+ const EcaruleParserRULE_prules

+ const EcaruleParserRULE_ruleDescription

+ const EcaruleParserRULE_ruleEntry

+ const EcaruleParserRULE_ruleName

+ const EcaruleParserRULE_salience

+ const EcaruleParserRULE_stringLiteral

+ const EcaruleParserRULE_tailActions

+ const EcaruleParserRULE_task

+ const EcaruleParserRULE_thenExpression

+ const EcaruleParserRULE_thenExpressionList

+ const EcaruleParserRULE_thenScope

+ const EcaruleParserRULE_variable

+ const EcaruleParserRULE_whenScope

+ const EcaruleParserSALIENCE

+ const EcaruleParserSEMICOLON

+ const EcaruleParserSIMPLENAME

+ const EcaruleParserSPACE

+ const EcaruleParserSQUOTA_STRING

+ const EcaruleParserTHEN

+ const EcaruleParserTRUE

+ const EcaruleParserT__0

+ const EcaruleParserWHEN

+ func EcaruleLexerInit()

+ func EcaruleParserInit()

+ type ActionsContext struct

+ func NewActionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ActionsContext

+ func NewEmptyActionsContext() *ActionsContext

+ func (*ActionsContext) IsActionsContext()

+ func (s *ActionsContext) Assignment() IAssignmentContext

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

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

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

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

+ func (s *ActionsContext) TailActions() ITailActionsContext

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

+ type AddMinusOperatorsContext struct

+ func NewAddMinusOperatorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddMinusOperatorsContext

+ func NewEmptyAddMinusOperatorsContext() *AddMinusOperatorsContext

+ func (*AddMinusOperatorsContext) IsAddMinusOperatorsContext()

+ func (s *AddMinusOperatorsContext) BITAND() antlr.TerminalNode

+ func (s *AddMinusOperatorsContext) BITOR() antlr.TerminalNode

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

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

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

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

+ func (s *AddMinusOperatorsContext) MINUS() antlr.TerminalNode

+ func (s *AddMinusOperatorsContext) PLUS() antlr.TerminalNode

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

+ type AndLogicOperatorContext struct

+ func NewAndLogicOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AndLogicOperatorContext

+ func NewEmptyAndLogicOperatorContext() *AndLogicOperatorContext

+ func (*AndLogicOperatorContext) IsAndLogicOperatorContext()

+ func (s *AndLogicOperatorContext) AND() antlr.TerminalNode

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

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

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

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

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

+ type ArgumentListContext struct

+ func NewArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentListContext

+ func NewEmptyArgumentListContext() *ArgumentListContext

+ func (*ArgumentListContext) IsArgumentListContext()

+ func (s *ArgumentListContext) AllExpression() []IExpressionContext

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

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

+ func (s *ArgumentListContext) Expression(i int) IExpressionContext

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

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

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

+ type ArrayMapSelectorContext struct

+ func NewArrayMapSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayMapSelectorContext

+ func NewEmptyArrayMapSelectorContext() *ArrayMapSelectorContext

+ func (*ArrayMapSelectorContext) IsArrayMapSelectorContext()

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

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

+ func (s *ArrayMapSelectorContext) Expression() IExpressionContext

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

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

+ func (s *ArrayMapSelectorContext) LS_BRACKET() antlr.TerminalNode

+ func (s *ArrayMapSelectorContext) RS_BRACKET() antlr.TerminalNode

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

+ type AssignmentContext struct

+ func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext

+ func NewEmptyAssignmentContext() *AssignmentContext

+ func (*AssignmentContext) IsAssignmentContext()

+ func (s *AssignmentContext) ASSIGN() antlr.TerminalNode

+ func (s *AssignmentContext) DIV_ASIGN() antlr.TerminalNode

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

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

+ func (s *AssignmentContext) Expression() IExpressionContext

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

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

+ func (s *AssignmentContext) MINUS_ASIGN() antlr.TerminalNode

+ func (s *AssignmentContext) MUL_ASIGN() antlr.TerminalNode

+ func (s *AssignmentContext) PLUS_ASIGN() antlr.TerminalNode

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

+ func (s *AssignmentContext) Variable() IVariableContext

+ type BooleanLiteralContext struct

+ func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext

+ func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

+ func (*BooleanLiteralContext) IsBooleanLiteralContext()

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

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

+ func (s *BooleanLiteralContext) FALSE() antlr.TerminalNode

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

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

+ func (s *BooleanLiteralContext) TRUE() antlr.TerminalNode

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

+ type ComparisonOperatorContext struct

+ func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext

+ func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext

+ func (*ComparisonOperatorContext) IsComparisonOperatorContext()

+ func (s *ComparisonOperatorContext) EQUALS() antlr.TerminalNode

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

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

+ func (s *ComparisonOperatorContext) GT() antlr.TerminalNode

+ func (s *ComparisonOperatorContext) GTE() antlr.TerminalNode

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

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

+ func (s *ComparisonOperatorContext) LT() antlr.TerminalNode

+ func (s *ComparisonOperatorContext) LTE() antlr.TerminalNode

+ func (s *ComparisonOperatorContext) NOTEQUALS() antlr.TerminalNode

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

+ type ConstantContext struct

+ func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext

+ func NewEmptyConstantContext() *ConstantContext

+ func (*ConstantContext) IsConstantContext()

+ func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext

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

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

+ func (s *ConstantContext) FloatLiteral() IFloatLiteralContext

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

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

+ func (s *ConstantContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *ConstantContext) NIL_LITERAL() antlr.TerminalNode

+ func (s *ConstantContext) StringLiteral() IStringLiteralContext

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

+ type DecimalFloatLiteralContext struct

+ func NewDecimalFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalFloatLiteralContext

+ func NewEmptyDecimalFloatLiteralContext() *DecimalFloatLiteralContext

+ func (*DecimalFloatLiteralContext) IsDecimalFloatLiteralContext()

+ func (s *DecimalFloatLiteralContext) DECIMAL_FLOAT_LIT() antlr.TerminalNode

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

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

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

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

+ func (s *DecimalFloatLiteralContext) MINUS() antlr.TerminalNode

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

+ type DecimalLiteralContext struct

+ func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext

+ func NewEmptyDecimalLiteralContext() *DecimalLiteralContext

+ func (*DecimalLiteralContext) IsDecimalLiteralContext()

+ func (s *DecimalLiteralContext) DEC_LIT() antlr.TerminalNode

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

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

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

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

+ func (s *DecimalLiteralContext) MINUS() antlr.TerminalNode

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

+ type DefaultActionsContext struct

+ func NewDefaultActionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultActionsContext

+ func NewEmptyDefaultActionsContext() *DefaultActionsContext

+ func (*DefaultActionsContext) IsDefaultActionsContext()

+ func (s *DefaultActionsContext) Actions() IActionsContext

+ func (s *DefaultActionsContext) DEFAULT() antlr.TerminalNode

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

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

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

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

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

+ type EcaruleLexer struct

+ func NewEcaruleLexer(input antlr.CharStream) *EcaruleLexer

+ type EcaruleParser struct

+ func NewEcaruleParser(input antlr.TokenStream) *EcaruleParser

+ func (p *EcaruleParser) Actions() (localctx IActionsContext)

+ func (p *EcaruleParser) AddMinusOperators() (localctx IAddMinusOperatorsContext)

+ func (p *EcaruleParser) AndLogicOperator() (localctx IAndLogicOperatorContext)

+ func (p *EcaruleParser) ArgumentList() (localctx IArgumentListContext)

+ func (p *EcaruleParser) ArrayMapSelector() (localctx IArrayMapSelectorContext)

+ func (p *EcaruleParser) Assignment() (localctx IAssignmentContext)

+ func (p *EcaruleParser) BooleanLiteral() (localctx IBooleanLiteralContext)

+ func (p *EcaruleParser) ComparisonOperator() (localctx IComparisonOperatorContext)

+ func (p *EcaruleParser) Constant() (localctx IConstantContext)

+ func (p *EcaruleParser) DecimalFloatLiteral() (localctx IDecimalFloatLiteralContext)

+ func (p *EcaruleParser) DecimalLiteral() (localctx IDecimalLiteralContext)

+ func (p *EcaruleParser) DefaultActions() (localctx IDefaultActionsContext)

+ func (p *EcaruleParser) Events() (localctx IEventsContext)

+ func (p *EcaruleParser) Expression() (localctx IExpressionContext)

+ func (p *EcaruleParser) ExpressionAtom() (localctx IExpressionAtomContext)

+ func (p *EcaruleParser) ExpressionAtom_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *EcaruleParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *EcaruleParser) FloatLiteral() (localctx IFloatLiteralContext)

+ func (p *EcaruleParser) FunctionCall() (localctx IFunctionCallContext)

+ func (p *EcaruleParser) Grl() (localctx IGrlContext)

+ func (p *EcaruleParser) HexadecimalFloatLiteral() (localctx IHexadecimalFloatLiteralContext)

+ func (p *EcaruleParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext)

+ func (p *EcaruleParser) IntegerLiteral() (localctx IIntegerLiteralContext)

+ func (p *EcaruleParser) MaybeActions() (localctx IMaybeActionsContext)

+ func (p *EcaruleParser) MemberVariable() (localctx IMemberVariableContext)

+ func (p *EcaruleParser) MethodCall() (localctx IMethodCallContext)

+ func (p *EcaruleParser) MulDivOperators() (localctx IMulDivOperatorsContext)

+ func (p *EcaruleParser) OctalLiteral() (localctx IOctalLiteralContext)

+ func (p *EcaruleParser) OrLogicOperator() (localctx IOrLogicOperatorContext)

+ func (p *EcaruleParser) Prule() (localctx IPruleContext)

+ func (p *EcaruleParser) Prules() (localctx IPrulesContext)

+ func (p *EcaruleParser) RuleDescription() (localctx IRuleDescriptionContext)

+ func (p *EcaruleParser) RuleEntry() (localctx IRuleEntryContext)

+ func (p *EcaruleParser) RuleName() (localctx IRuleNameContext)

+ func (p *EcaruleParser) Salience() (localctx ISalienceContext)

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

+ func (p *EcaruleParser) StringLiteral() (localctx IStringLiteralContext)

+ func (p *EcaruleParser) TailActions() (localctx ITailActionsContext)

+ func (p *EcaruleParser) Task() (localctx ITaskContext)

+ func (p *EcaruleParser) ThenExpression() (localctx IThenExpressionContext)

+ func (p *EcaruleParser) ThenExpressionList() (localctx IThenExpressionListContext)

+ func (p *EcaruleParser) ThenScope() (localctx IThenScopeContext)

+ func (p *EcaruleParser) Variable() (localctx IVariableContext)

+ func (p *EcaruleParser) Variable_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *EcaruleParser) WhenScope() (localctx IWhenScopeContext)

+ type EcaruleParserListener interface

+ EnterActions func(c *ActionsContext)

+ EnterAddMinusOperators func(c *grulev3.AddMinusOperatorsContext)

+ EnterAndLogicOperator func(c *grulev3.AndLogicOperatorContext)

+ EnterArgumentList func(c *grulev3.ArgumentListContext)

+ EnterArrayMapSelector func(c *grulev3.ArrayMapSelectorContext)

+ EnterAssignment func(c *grulev3.AssignmentContext)

+ EnterBooleanLiteral func(c *grulev3.BooleanLiteralContext)

+ EnterComparisonOperator func(c *grulev3.ComparisonOperatorContext)

+ EnterConstant func(c *grulev3.ConstantContext)

+ EnterDecimalFloatLiteral func(c *grulev3.DecimalFloatLiteralContext)

+ EnterDecimalLiteral func(c *grulev3.DecimalLiteralContext)

+ EnterDefaultActions func(c *DefaultActionsContext)

+ EnterEvents func(c *EventsContext)

+ EnterExpression func(c *grulev3.ExpressionContext)

+ EnterExpressionAtom func(c *grulev3.ExpressionAtomContext)

+ EnterFloatLiteral func(c *grulev3.FloatLiteralContext)

+ EnterFunctionCall func(c *grulev3.FunctionCallContext)

+ EnterGrl func(c *grulev3.GrlContext)

+ EnterHexadecimalFloatLiteral func(c *grulev3.HexadecimalFloatLiteralContext)

+ EnterHexadecimalLiteral func(c *grulev3.HexadecimalLiteralContext)

+ EnterIntegerLiteral func(c *grulev3.IntegerLiteralContext)

+ EnterMaybeActions func(c *MaybeActionsContext)

+ EnterMemberVariable func(c *grulev3.MemberVariableContext)

+ EnterMethodCall func(c *grulev3.MethodCallContext)

+ EnterMulDivOperators func(c *grulev3.MulDivOperatorsContext)

+ EnterOctalLiteral func(c *grulev3.OctalLiteralContext)

+ EnterOrLogicOperator func(c *grulev3.OrLogicOperatorContext)

+ EnterPrule func(c *PruleContext)

+ EnterPrules func(c *PrulesContext)

+ EnterRuleDescription func(c *grulev3.RuleDescriptionContext)

+ EnterRuleEntry func(c *grulev3.RuleEntryContext)

+ EnterRuleName func(c *grulev3.RuleNameContext)

+ EnterSalience func(c *grulev3.SalienceContext)

+ EnterStringLiteral func(c *grulev3.StringLiteralContext)

+ EnterTailActions func(c *TailActionsContext)

+ EnterTask func(c *TaskContext)

+ EnterThenExpression func(c *grulev3.ThenExpressionContext)

+ EnterThenExpressionList func(c *grulev3.ThenExpressionListContext)

+ EnterThenScope func(c *grulev3.ThenScopeContext)

+ EnterVariable func(c *grulev3.VariableContext)

+ EnterWhenScope func(c *grulev3.WhenScopeContext)

+ ExitActions func(c *ActionsContext)

+ ExitAddMinusOperators func(c *grulev3.AddMinusOperatorsContext)

+ ExitAndLogicOperator func(c *grulev3.AndLogicOperatorContext)

+ ExitArgumentList func(c *grulev3.ArgumentListContext)

+ ExitArrayMapSelector func(c *grulev3.ArrayMapSelectorContext)

+ ExitAssignment func(c *grulev3.AssignmentContext)

+ ExitBooleanLiteral func(c *grulev3.BooleanLiteralContext)

+ ExitComparisonOperator func(c *grulev3.ComparisonOperatorContext)

+ ExitConstant func(c *grulev3.ConstantContext)

+ ExitDecimalFloatLiteral func(c *grulev3.DecimalFloatLiteralContext)

+ ExitDecimalLiteral func(c *grulev3.DecimalLiteralContext)

+ ExitDefaultActions func(c *DefaultActionsContext)

+ ExitEvents func(c *EventsContext)

+ ExitExpression func(c *grulev3.ExpressionContext)

+ ExitExpressionAtom func(c *grulev3.ExpressionAtomContext)

+ ExitFloatLiteral func(c *grulev3.FloatLiteralContext)

+ ExitFunctionCall func(c *grulev3.FunctionCallContext)

+ ExitGrl func(c *grulev3.GrlContext)

+ ExitHexadecimalFloatLiteral func(c *grulev3.HexadecimalFloatLiteralContext)

+ ExitHexadecimalLiteral func(c *grulev3.HexadecimalLiteralContext)

+ ExitIntegerLiteral func(c *grulev3.IntegerLiteralContext)

+ ExitMaybeActions func(c *MaybeActionsContext)

+ ExitMemberVariable func(c *grulev3.MemberVariableContext)

+ ExitMethodCall func(c *grulev3.MethodCallContext)

+ ExitMulDivOperators func(c *grulev3.MulDivOperatorsContext)

+ ExitOctalLiteral func(c *grulev3.OctalLiteralContext)

+ ExitOrLogicOperator func(c *grulev3.OrLogicOperatorContext)

+ ExitPrule func(c *PruleContext)

+ ExitPrules func(c *PrulesContext)

+ ExitRuleDescription func(c *grulev3.RuleDescriptionContext)

+ ExitRuleEntry func(c *grulev3.RuleEntryContext)

+ ExitRuleName func(c *grulev3.RuleNameContext)

+ ExitSalience func(c *grulev3.SalienceContext)

+ ExitStringLiteral func(c *grulev3.StringLiteralContext)

+ ExitTailActions func(c *TailActionsContext)

+ ExitTask func(c *TaskContext)

+ ExitThenExpression func(c *grulev3.ThenExpressionContext)

+ ExitThenExpressionList func(c *grulev3.ThenExpressionListContext)

+ ExitThenScope func(c *grulev3.ThenScopeContext)

+ ExitVariable func(c *grulev3.VariableContext)

+ ExitWhenScope func(c *grulev3.WhenScopeContext)

+ type EventsContext struct

+ func NewEmptyEventsContext() *EventsContext

+ func NewEventsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventsContext

+ func (*EventsContext) IsEventsContext()

+ func (s *EventsContext) AllSIMPLENAME() []antlr.TerminalNode

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

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

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

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

+ func (s *EventsContext) SIMPLENAME(i int) antlr.TerminalNode

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

+ type ExpressionAtomContext struct

+ func NewEmptyExpressionAtomContext() *ExpressionAtomContext

+ func NewExpressionAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAtomContext

+ func (*ExpressionAtomContext) IsExpressionAtomContext()

+ func (s *ExpressionAtomContext) ArrayMapSelector() IArrayMapSelectorContext

+ func (s *ExpressionAtomContext) Constant() IConstantContext

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

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

+ func (s *ExpressionAtomContext) ExpressionAtom() IExpressionAtomContext

+ func (s *ExpressionAtomContext) FunctionCall() IFunctionCallContext

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

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

+ func (s *ExpressionAtomContext) MemberVariable() IMemberVariableContext

+ func (s *ExpressionAtomContext) MethodCall() IMethodCallContext

+ func (s *ExpressionAtomContext) NEGATION() antlr.TerminalNode

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

+ func (s *ExpressionAtomContext) Variable() IVariableContext

+ type ExpressionContext struct

+ func NewEmptyExpressionContext() *ExpressionContext

+ func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext

+ func (*ExpressionContext) IsExpressionContext()

+ func (s *ExpressionContext) AddMinusOperators() IAddMinusOperatorsContext

+ func (s *ExpressionContext) AllExpression() []IExpressionContext

+ func (s *ExpressionContext) AndLogicOperator() IAndLogicOperatorContext

+ func (s *ExpressionContext) ComparisonOperator() IComparisonOperatorContext

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

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

+ func (s *ExpressionContext) Expression(i int) IExpressionContext

+ func (s *ExpressionContext) ExpressionAtom() IExpressionAtomContext

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

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

+ func (s *ExpressionContext) LR_BRACKET() antlr.TerminalNode

+ func (s *ExpressionContext) MulDivOperators() IMulDivOperatorsContext

+ func (s *ExpressionContext) NEGATION() antlr.TerminalNode

+ func (s *ExpressionContext) OrLogicOperator() IOrLogicOperatorContext

+ func (s *ExpressionContext) RR_BRACKET() antlr.TerminalNode

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

+ type FloatLiteralContext struct

+ func NewEmptyFloatLiteralContext() *FloatLiteralContext

+ func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext

+ func (*FloatLiteralContext) IsFloatLiteralContext()

+ func (s *FloatLiteralContext) DecimalFloatLiteral() IDecimalFloatLiteralContext

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

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

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

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

+ func (s *FloatLiteralContext) HexadecimalFloatLiteral() IHexadecimalFloatLiteralContext

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

+ type FunctionCallContext struct

+ func NewEmptyFunctionCallContext() *FunctionCallContext

+ func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext

+ func (*FunctionCallContext) IsFunctionCallContext()

+ func (s *FunctionCallContext) ArgumentList() IArgumentListContext

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

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

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

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

+ func (s *FunctionCallContext) LR_BRACKET() antlr.TerminalNode

+ func (s *FunctionCallContext) RR_BRACKET() antlr.TerminalNode

+ func (s *FunctionCallContext) SIMPLENAME() antlr.TerminalNode

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

+ type GrlContext struct

+ func NewEmptyGrlContext() *GrlContext

+ func NewGrlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrlContext

+ func (*GrlContext) IsGrlContext()

+ func (s *GrlContext) AllRuleEntry() []IRuleEntryContext

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

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

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

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

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

+ func (s *GrlContext) RuleEntry(i int) IRuleEntryContext

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

+ type HexadecimalFloatLiteralContext struct

+ func NewEmptyHexadecimalFloatLiteralContext() *HexadecimalFloatLiteralContext

+ func NewHexadecimalFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalFloatLiteralContext

+ func (*HexadecimalFloatLiteralContext) IsHexadecimalFloatLiteralContext()

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

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

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

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

+ func (s *HexadecimalFloatLiteralContext) HEX_FLOAT_LIT() antlr.TerminalNode

+ func (s *HexadecimalFloatLiteralContext) MINUS() antlr.TerminalNode

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

+ type HexadecimalLiteralContext struct

+ func NewEmptyHexadecimalLiteralContext() *HexadecimalLiteralContext

+ func NewHexadecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalLiteralContext

+ func (*HexadecimalLiteralContext) IsHexadecimalLiteralContext()

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

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

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

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

+ func (s *HexadecimalLiteralContext) HEX_LIT() antlr.TerminalNode

+ func (s *HexadecimalLiteralContext) MINUS() antlr.TerminalNode

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

+ type IActionsContext interface

+ GetParser func() antlr.Parser

+ IsActionsContext func()

+ type IAddMinusOperatorsContext interface

+ GetParser func() antlr.Parser

+ IsAddMinusOperatorsContext func()

+ type IAndLogicOperatorContext interface

+ GetParser func() antlr.Parser

+ IsAndLogicOperatorContext func()

+ type IArgumentListContext interface

+ GetParser func() antlr.Parser

+ IsArgumentListContext func()

+ type IArrayMapSelectorContext interface

+ GetParser func() antlr.Parser

+ IsArrayMapSelectorContext func()

+ type IAssignmentContext interface

+ GetParser func() antlr.Parser

+ IsAssignmentContext func()

+ type IBooleanLiteralContext interface

+ GetParser func() antlr.Parser

+ IsBooleanLiteralContext func()

+ type IComparisonOperatorContext interface

+ GetParser func() antlr.Parser

+ IsComparisonOperatorContext func()

+ type IConstantContext interface

+ GetParser func() antlr.Parser

+ IsConstantContext func()

+ type IDecimalFloatLiteralContext interface

+ GetParser func() antlr.Parser

+ IsDecimalFloatLiteralContext func()

+ type IDecimalLiteralContext interface

+ GetParser func() antlr.Parser

+ IsDecimalLiteralContext func()

+ type IDefaultActionsContext interface

+ GetParser func() antlr.Parser

+ IsDefaultActionsContext func()

+ type IEventsContext interface

+ GetParser func() antlr.Parser

+ IsEventsContext func()

+ type IExpressionAtomContext interface

+ GetParser func() antlr.Parser

+ IsExpressionAtomContext func()

+ type IExpressionContext interface

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ type IFloatLiteralContext interface

+ GetParser func() antlr.Parser

+ IsFloatLiteralContext func()

+ type IFunctionCallContext interface

+ GetParser func() antlr.Parser

+ IsFunctionCallContext func()

+ type IGrlContext interface

+ GetParser func() antlr.Parser

+ IsGrlContext func()

+ type IHexadecimalFloatLiteralContext interface

+ GetParser func() antlr.Parser

+ IsHexadecimalFloatLiteralContext func()

+ type IHexadecimalLiteralContext interface

+ GetParser func() antlr.Parser

+ IsHexadecimalLiteralContext func()

+ type IIntegerLiteralContext interface

+ GetParser func() antlr.Parser

+ IsIntegerLiteralContext func()

+ type IMaybeActionsContext interface

+ GetParser func() antlr.Parser

+ IsMaybeActionsContext func()

+ type IMemberVariableContext interface

+ GetParser func() antlr.Parser

+ IsMemberVariableContext func()

+ type IMethodCallContext interface

+ GetParser func() antlr.Parser

+ IsMethodCallContext func()

+ type IMulDivOperatorsContext interface

+ GetParser func() antlr.Parser

+ IsMulDivOperatorsContext func()

+ type IOctalLiteralContext interface

+ GetParser func() antlr.Parser

+ IsOctalLiteralContext func()

+ type IOrLogicOperatorContext interface

+ GetParser func() antlr.Parser

+ IsOrLogicOperatorContext func()

+ type IPruleContext interface

+ GetParser func() antlr.Parser

+ IsPruleContext func()

+ type IPrulesContext interface

+ GetParser func() antlr.Parser

+ IsPrulesContext func()

+ type IRuleDescriptionContext interface

+ GetParser func() antlr.Parser

+ IsRuleDescriptionContext func()

+ type IRuleEntryContext interface

+ GetParser func() antlr.Parser

+ IsRuleEntryContext func()

+ type IRuleNameContext interface

+ GetParser func() antlr.Parser

+ IsRuleNameContext func()

+ type ISalienceContext interface

+ GetParser func() antlr.Parser

+ IsSalienceContext func()

+ type IStringLiteralContext interface

+ GetParser func() antlr.Parser

+ IsStringLiteralContext func()

+ type ITailActionsContext interface

+ GetParser func() antlr.Parser

+ IsTailActionsContext func()

+ type ITaskContext interface

+ GetParser func() antlr.Parser

+ IsTaskContext func()

+ type IThenExpressionContext interface

+ GetParser func() antlr.Parser

+ IsThenExpressionContext func()

+ type IThenExpressionListContext interface

+ GetParser func() antlr.Parser

+ IsThenExpressionListContext func()

+ type IThenScopeContext interface

+ GetParser func() antlr.Parser

+ IsThenScopeContext func()

+ type IVariableContext interface

+ GetParser func() antlr.Parser

+ IsVariableContext func()

+ type IWhenScopeContext interface

+ GetParser func() antlr.Parser

+ IsWhenScopeContext func()

+ type IntegerLiteralContext struct

+ func NewEmptyIntegerLiteralContext() *IntegerLiteralContext

+ func NewIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerLiteralContext

+ func (*IntegerLiteralContext) IsIntegerLiteralContext()

+ func (s *IntegerLiteralContext) DecimalLiteral() IDecimalLiteralContext

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

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

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

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

+ func (s *IntegerLiteralContext) HexadecimalLiteral() IHexadecimalLiteralContext

+ func (s *IntegerLiteralContext) OctalLiteral() IOctalLiteralContext

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

+ type MaybeActionsContext struct

+ func NewEmptyMaybeActionsContext() *MaybeActionsContext

+ func NewMaybeActionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaybeActionsContext

+ func (*MaybeActionsContext) IsMaybeActionsContext()

+ func (s *MaybeActionsContext) Actions() IActionsContext

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

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

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

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

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

+ type MemberVariableContext struct

+ func NewEmptyMemberVariableContext() *MemberVariableContext

+ func NewMemberVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberVariableContext

+ func (*MemberVariableContext) IsMemberVariableContext()

+ func (s *MemberVariableContext) DOT() antlr.TerminalNode

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

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

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

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

+ func (s *MemberVariableContext) SIMPLENAME() antlr.TerminalNode

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

+ type MethodCallContext struct

+ func NewEmptyMethodCallContext() *MethodCallContext

+ func NewMethodCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodCallContext

+ func (*MethodCallContext) IsMethodCallContext()

+ func (s *MethodCallContext) DOT() antlr.TerminalNode

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

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

+ func (s *MethodCallContext) FunctionCall() IFunctionCallContext

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

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

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

+ type MulDivOperatorsContext struct

+ func NewEmptyMulDivOperatorsContext() *MulDivOperatorsContext

+ func NewMulDivOperatorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MulDivOperatorsContext

+ func (*MulDivOperatorsContext) IsMulDivOperatorsContext()

+ func (s *MulDivOperatorsContext) DIV() antlr.TerminalNode

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

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

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

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

+ func (s *MulDivOperatorsContext) MOD() antlr.TerminalNode

+ func (s *MulDivOperatorsContext) MUL() antlr.TerminalNode

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

+ type OctalLiteralContext struct

+ func NewEmptyOctalLiteralContext() *OctalLiteralContext

+ func NewOctalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OctalLiteralContext

+ func (*OctalLiteralContext) IsOctalLiteralContext()

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

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

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

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

+ func (s *OctalLiteralContext) MINUS() antlr.TerminalNode

+ func (s *OctalLiteralContext) OCT_LIT() antlr.TerminalNode

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

+ type OrLogicOperatorContext struct

+ func NewEmptyOrLogicOperatorContext() *OrLogicOperatorContext

+ func NewOrLogicOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrLogicOperatorContext

+ func (*OrLogicOperatorContext) IsOrLogicOperatorContext()

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

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

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

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

+ func (s *OrLogicOperatorContext) OR() antlr.TerminalNode

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

+ type PruleContext struct

+ func NewEmptyPruleContext() *PruleContext

+ func NewPruleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PruleContext

+ func (*PruleContext) IsPruleContext()

+ func (s *PruleContext) AllTask() []ITaskContext

+ func (s *PruleContext) DefaultActions() IDefaultActionsContext

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

+ func (s *PruleContext) Events() IEventsContext

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

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

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

+ func (s *PruleContext) ON() antlr.TerminalNode

+ func (s *PruleContext) RULE() antlr.TerminalNode

+ func (s *PruleContext) SIMPLENAME() antlr.TerminalNode

+ func (s *PruleContext) Task(i int) ITaskContext

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

+ type PrulesContext struct

+ func NewEmptyPrulesContext() *PrulesContext

+ func NewPrulesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrulesContext

+ func (*PrulesContext) IsPrulesContext()

+ func (s *PrulesContext) AllPrule() []IPruleContext

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

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

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

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

+ func (s *PrulesContext) Prule(i int) IPruleContext

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

+ type RuleDescriptionContext struct

+ func NewEmptyRuleDescriptionContext() *RuleDescriptionContext

+ func NewRuleDescriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleDescriptionContext

+ func (*RuleDescriptionContext) IsRuleDescriptionContext()

+ func (s *RuleDescriptionContext) DQUOTA_STRING() antlr.TerminalNode

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

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

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

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

+ func (s *RuleDescriptionContext) SQUOTA_STRING() antlr.TerminalNode

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

+ type RuleEntryContext struct

+ func NewEmptyRuleEntryContext() *RuleEntryContext

+ func NewRuleEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleEntryContext

+ func (*RuleEntryContext) IsRuleEntryContext()

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

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

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

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

+ func (s *RuleEntryContext) LR_BRACE() antlr.TerminalNode

+ func (s *RuleEntryContext) RR_BRACE() antlr.TerminalNode

+ func (s *RuleEntryContext) RULE() antlr.TerminalNode

+ func (s *RuleEntryContext) RuleDescription() IRuleDescriptionContext

+ func (s *RuleEntryContext) RuleName() IRuleNameContext

+ func (s *RuleEntryContext) Salience() ISalienceContext

+ func (s *RuleEntryContext) ThenScope() IThenScopeContext

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

+ func (s *RuleEntryContext) WhenScope() IWhenScopeContext

+ type RuleNameContext struct

+ func NewEmptyRuleNameContext() *RuleNameContext

+ func NewRuleNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleNameContext

+ func (*RuleNameContext) IsRuleNameContext()

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

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

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

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

+ func (s *RuleNameContext) SIMPLENAME() antlr.TerminalNode

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

+ type SalienceContext struct

+ func NewEmptySalienceContext() *SalienceContext

+ func NewSalienceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SalienceContext

+ func (*SalienceContext) IsSalienceContext()

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

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

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

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

+ func (s *SalienceContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *SalienceContext) SALIENCE() antlr.TerminalNode

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

+ type StringLiteralContext struct

+ func NewEmptyStringLiteralContext() *StringLiteralContext

+ func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext

+ func (*StringLiteralContext) IsStringLiteralContext()

+ func (s *StringLiteralContext) DQUOTA_STRING() antlr.TerminalNode

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

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

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

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

+ func (s *StringLiteralContext) SQUOTA_STRING() antlr.TerminalNode

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

+ type TailActionsContext struct

+ func NewEmptyTailActionsContext() *TailActionsContext

+ func NewTailActionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TailActionsContext

+ func (*TailActionsContext) IsTailActionsContext()

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

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

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

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

+ func (s *TailActionsContext) MaybeActions() IMaybeActionsContext

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

+ type TaskContext struct

+ func NewEmptyTaskContext() *TaskContext

+ func NewTaskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TaskContext

+ func (*TaskContext) IsTaskContext()

+ func (s *TaskContext) ALL() antlr.TerminalNode

+ func (s *TaskContext) Actions() IActionsContext

+ func (s *TaskContext) DO() antlr.TerminalNode

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

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

+ func (s *TaskContext) Expression() IExpressionContext

+ func (s *TaskContext) FOR() antlr.TerminalNode

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

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

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

+ type ThenExpressionContext struct

+ func NewEmptyThenExpressionContext() *ThenExpressionContext

+ func NewThenExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThenExpressionContext

+ func (*ThenExpressionContext) IsThenExpressionContext()

+ func (s *ThenExpressionContext) Assignment() IAssignmentContext

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

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

+ func (s *ThenExpressionContext) ExpressionAtom() IExpressionAtomContext

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

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

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

+ type ThenExpressionListContext struct

+ func NewEmptyThenExpressionListContext() *ThenExpressionListContext

+ func NewThenExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThenExpressionListContext

+ func (*ThenExpressionListContext) IsThenExpressionListContext()

+ func (s *ThenExpressionListContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *ThenExpressionListContext) AllThenExpression() []IThenExpressionContext

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

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

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

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

+ func (s *ThenExpressionListContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *ThenExpressionListContext) ThenExpression(i int) IThenExpressionContext

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

+ type ThenScopeContext struct

+ func NewEmptyThenScopeContext() *ThenScopeContext

+ func NewThenScopeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThenScopeContext

+ func (*ThenScopeContext) IsThenScopeContext()

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

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

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

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

+ func (s *ThenScopeContext) THEN() antlr.TerminalNode

+ func (s *ThenScopeContext) ThenExpressionList() IThenExpressionListContext

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

+ type VariableContext struct

+ func NewEmptyVariableContext() *VariableContext

+ func NewVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableContext

+ func (*VariableContext) IsVariableContext()

+ func (s *VariableContext) ArrayMapSelector() IArrayMapSelectorContext

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

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

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

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

+ func (s *VariableContext) MemberVariable() IMemberVariableContext

+ func (s *VariableContext) SIMPLENAME() antlr.TerminalNode

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

+ func (s *VariableContext) Variable() IVariableContext

+ type WhenScopeContext struct

+ func NewEmptyWhenScopeContext() *WhenScopeContext

+ func NewWhenScopeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenScopeContext

+ func (*WhenScopeContext) IsWhenScopeContext()

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

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

+ func (s *WhenScopeContext) Expression() IExpressionContext

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

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

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

+ func (s *WhenScopeContext) WHEN() antlr.TerminalNode