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

grulev3

package

Go to main page

Versions in this module

v0

v0.1.10

Nov 23, 2023

v0.1.9

Nov 22, 2023

v0.1.8

Nov 22, 2023

v0.1.7

Nov 22, 2023

v0.1.6

Nov 22, 2023

v0.1.5

Nov 21, 2023

v0.1.4

Nov 21, 2023

v0.1.3

Nov 10, 2023

v0.1.2

Nov 10, 2023

Changes in this version

+ func Grulev3LexerInit()

+ func Grulev3ParserInit()

+ func Newgrulev3Lexer(input antlr.CharStream) *grulev3Lexer

+ func Newgrulev3Parser(input antlr.TokenStream) *grulev3Parser

+ type AddMinusOperatorsContext struct

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

+ func NewEmptyAddMinusOperatorsContext() *AddMinusOperatorsContext

+ func (*AddMinusOperatorsContext) IsAddMinusOperatorsContext()

+ func (s *AddMinusOperatorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 Basegrulev3Listener struct

+ func (s *Basegrulev3Listener) EnterAddMinusOperators(ctx *AddMinusOperatorsContext)

+ func (s *Basegrulev3Listener) EnterAndLogicOperator(ctx *AndLogicOperatorContext)

+ func (s *Basegrulev3Listener) EnterArgumentList(ctx *ArgumentListContext)

+ func (s *Basegrulev3Listener) EnterArrayMapSelector(ctx *ArrayMapSelectorContext)

+ func (s *Basegrulev3Listener) EnterAssignment(ctx *AssignmentContext)

+ func (s *Basegrulev3Listener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *Basegrulev3Listener) EnterComparisonOperator(ctx *ComparisonOperatorContext)

+ func (s *Basegrulev3Listener) EnterConstant(ctx *ConstantContext)

+ func (s *Basegrulev3Listener) EnterDecimalFloatLiteral(ctx *DecimalFloatLiteralContext)

+ func (s *Basegrulev3Listener) EnterDecimalLiteral(ctx *DecimalLiteralContext)

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

+ func (s *Basegrulev3Listener) EnterExpression(ctx *ExpressionContext)

+ func (s *Basegrulev3Listener) EnterExpressionAtom(ctx *ExpressionAtomContext)

+ func (s *Basegrulev3Listener) EnterFloatLiteral(ctx *FloatLiteralContext)

+ func (s *Basegrulev3Listener) EnterFunctionCall(ctx *FunctionCallContext)

+ func (s *Basegrulev3Listener) EnterGrl(ctx *GrlContext)

+ func (s *Basegrulev3Listener) EnterHexadecimalFloatLiteral(ctx *HexadecimalFloatLiteralContext)

+ func (s *Basegrulev3Listener) EnterHexadecimalLiteral(ctx *HexadecimalLiteralContext)

+ func (s *Basegrulev3Listener) EnterIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *Basegrulev3Listener) EnterMemberVariable(ctx *MemberVariableContext)

+ func (s *Basegrulev3Listener) EnterMethodCall(ctx *MethodCallContext)

+ func (s *Basegrulev3Listener) EnterMulDivOperators(ctx *MulDivOperatorsContext)

+ func (s *Basegrulev3Listener) EnterOctalLiteral(ctx *OctalLiteralContext)

+ func (s *Basegrulev3Listener) EnterOrLogicOperator(ctx *OrLogicOperatorContext)

+ func (s *Basegrulev3Listener) EnterRuleDescription(ctx *RuleDescriptionContext)

+ func (s *Basegrulev3Listener) EnterRuleEntry(ctx *RuleEntryContext)

+ func (s *Basegrulev3Listener) EnterRuleName(ctx *RuleNameContext)

+ func (s *Basegrulev3Listener) EnterSalience(ctx *SalienceContext)

+ func (s *Basegrulev3Listener) EnterStringLiteral(ctx *StringLiteralContext)

+ func (s *Basegrulev3Listener) EnterThenExpression(ctx *ThenExpressionContext)

+ func (s *Basegrulev3Listener) EnterThenExpressionList(ctx *ThenExpressionListContext)

+ func (s *Basegrulev3Listener) EnterThenScope(ctx *ThenScopeContext)

+ func (s *Basegrulev3Listener) EnterVariable(ctx *VariableContext)

+ func (s *Basegrulev3Listener) EnterWhenScope(ctx *WhenScopeContext)

+ func (s *Basegrulev3Listener) ExitAddMinusOperators(ctx *AddMinusOperatorsContext)

+ func (s *Basegrulev3Listener) ExitAndLogicOperator(ctx *AndLogicOperatorContext)

+ func (s *Basegrulev3Listener) ExitArgumentList(ctx *ArgumentListContext)

+ func (s *Basegrulev3Listener) ExitArrayMapSelector(ctx *ArrayMapSelectorContext)

+ func (s *Basegrulev3Listener) ExitAssignment(ctx *AssignmentContext)

+ func (s *Basegrulev3Listener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *Basegrulev3Listener) ExitComparisonOperator(ctx *ComparisonOperatorContext)

+ func (s *Basegrulev3Listener) ExitConstant(ctx *ConstantContext)

+ func (s *Basegrulev3Listener) ExitDecimalFloatLiteral(ctx *DecimalFloatLiteralContext)

+ func (s *Basegrulev3Listener) ExitDecimalLiteral(ctx *DecimalLiteralContext)

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

+ func (s *Basegrulev3Listener) ExitExpression(ctx *ExpressionContext)

+ func (s *Basegrulev3Listener) ExitExpressionAtom(ctx *ExpressionAtomContext)

+ func (s *Basegrulev3Listener) ExitFloatLiteral(ctx *FloatLiteralContext)

+ func (s *Basegrulev3Listener) ExitFunctionCall(ctx *FunctionCallContext)

+ func (s *Basegrulev3Listener) ExitGrl(ctx *GrlContext)

+ func (s *Basegrulev3Listener) ExitHexadecimalFloatLiteral(ctx *HexadecimalFloatLiteralContext)

+ func (s *Basegrulev3Listener) ExitHexadecimalLiteral(ctx *HexadecimalLiteralContext)

+ func (s *Basegrulev3Listener) ExitIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *Basegrulev3Listener) ExitMemberVariable(ctx *MemberVariableContext)

+ func (s *Basegrulev3Listener) ExitMethodCall(ctx *MethodCallContext)

+ func (s *Basegrulev3Listener) ExitMulDivOperators(ctx *MulDivOperatorsContext)

+ func (s *Basegrulev3Listener) ExitOctalLiteral(ctx *OctalLiteralContext)

+ func (s *Basegrulev3Listener) ExitOrLogicOperator(ctx *OrLogicOperatorContext)

+ func (s *Basegrulev3Listener) ExitRuleDescription(ctx *RuleDescriptionContext)

+ func (s *Basegrulev3Listener) ExitRuleEntry(ctx *RuleEntryContext)

+ func (s *Basegrulev3Listener) ExitRuleName(ctx *RuleNameContext)

+ func (s *Basegrulev3Listener) ExitSalience(ctx *SalienceContext)

+ func (s *Basegrulev3Listener) ExitStringLiteral(ctx *StringLiteralContext)

+ func (s *Basegrulev3Listener) ExitThenExpression(ctx *ThenExpressionContext)

+ func (s *Basegrulev3Listener) ExitThenExpressionList(ctx *ThenExpressionListContext)

+ func (s *Basegrulev3Listener) ExitThenScope(ctx *ThenScopeContext)

+ func (s *Basegrulev3Listener) ExitVariable(ctx *VariableContext)

+ func (s *Basegrulev3Listener) ExitWhenScope(ctx *WhenScopeContext)

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

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

+ type Basegrulev3Visitor struct

+ func (v *Basegrulev3Visitor) VisitAddMinusOperators(ctx *AddMinusOperatorsContext) interface{}

+ func (v *Basegrulev3Visitor) VisitAndLogicOperator(ctx *AndLogicOperatorContext) interface{}

+ func (v *Basegrulev3Visitor) VisitArgumentList(ctx *ArgumentListContext) interface{}

+ func (v *Basegrulev3Visitor) VisitArrayMapSelector(ctx *ArrayMapSelectorContext) interface{}

+ func (v *Basegrulev3Visitor) VisitAssignment(ctx *AssignmentContext) interface{}

+ func (v *Basegrulev3Visitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{}

+ func (v *Basegrulev3Visitor) VisitConstant(ctx *ConstantContext) interface{}

+ func (v *Basegrulev3Visitor) VisitDecimalFloatLiteral(ctx *DecimalFloatLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitExpression(ctx *ExpressionContext) interface{}

+ func (v *Basegrulev3Visitor) VisitExpressionAtom(ctx *ExpressionAtomContext) interface{}

+ func (v *Basegrulev3Visitor) VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitFunctionCall(ctx *FunctionCallContext) interface{}

+ func (v *Basegrulev3Visitor) VisitGrl(ctx *GrlContext) interface{}

+ func (v *Basegrulev3Visitor) VisitHexadecimalFloatLiteral(ctx *HexadecimalFloatLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitHexadecimalLiteral(ctx *HexadecimalLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitMemberVariable(ctx *MemberVariableContext) interface{}

+ func (v *Basegrulev3Visitor) VisitMethodCall(ctx *MethodCallContext) interface{}

+ func (v *Basegrulev3Visitor) VisitMulDivOperators(ctx *MulDivOperatorsContext) interface{}

+ func (v *Basegrulev3Visitor) VisitOctalLiteral(ctx *OctalLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitOrLogicOperator(ctx *OrLogicOperatorContext) interface{}

+ func (v *Basegrulev3Visitor) VisitRuleDescription(ctx *RuleDescriptionContext) interface{}

+ func (v *Basegrulev3Visitor) VisitRuleEntry(ctx *RuleEntryContext) interface{}

+ func (v *Basegrulev3Visitor) VisitRuleName(ctx *RuleNameContext) interface{}

+ func (v *Basegrulev3Visitor) VisitSalience(ctx *SalienceContext) interface{}

+ func (v *Basegrulev3Visitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

+ func (v *Basegrulev3Visitor) VisitThenExpression(ctx *ThenExpressionContext) interface{}

+ func (v *Basegrulev3Visitor) VisitThenExpressionList(ctx *ThenExpressionListContext) interface{}

+ func (v *Basegrulev3Visitor) VisitThenScope(ctx *ThenScopeContext) interface{}

+ func (v *Basegrulev3Visitor) VisitVariable(ctx *VariableContext) interface{}

+ func (v *Basegrulev3Visitor) VisitWhenScope(ctx *WhenScopeContext) interface{}

+ type BooleanLiteralContext struct

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

+ func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

+ func (*BooleanLiteralContext) IsBooleanLiteralContext()

+ func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 ExpressionAtomContext struct

+ func NewEmptyExpressionAtomContext() *ExpressionAtomContext

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

+ func (*ExpressionAtomContext) IsExpressionAtomContext()

+ func (s *ExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 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 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 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 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 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 MemberVariableContext struct

+ func NewEmptyMemberVariableContext() *MemberVariableContext

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

+ func (*MemberVariableContext) IsMemberVariableContext()

+ func (s *MemberVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 RuleDescriptionContext struct

+ func NewEmptyRuleDescriptionContext() *RuleDescriptionContext

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

+ func (*RuleDescriptionContext) IsRuleDescriptionContext()

+ func (s *RuleDescriptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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 ThenExpressionContext struct

+ func NewEmptyThenExpressionContext() *ThenExpressionContext

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

+ func (*ThenExpressionContext) IsThenExpressionContext()

+ func (s *ThenExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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