gen

May 15, 2024

Changes in this version

+ var Excellent1LexerLexerStaticData struct

+ var Excellent1ParserStaticData struct

+ func InitEmptyExpressionContext(p *ExpressionContext)

+ func InitEmptyFnnameContext(p *FnnameContext)

+ func InitEmptyParametersContext(p *ParametersContext)

+ func InitEmptyParseContext(p *ParseContext)

type ExpressionContext

+ func (s *ExpressionContext) CopyAll(ctx *ExpressionContext)

type IFnnameContext

+ FALSE func() antlr.TerminalNode

+ NAME func() antlr.TerminalNode

+ TRUE func() antlr.TerminalNode

type IParseContext

+ EOF func() antlr.TerminalNode

+ Expression func() IExpressionContext

type ParametersContext

+ func (s *ParametersContext) CopyAll(ctx *ParametersContext)

Feb 2, 2023

Changes in this version

+ const Excellent1LexerAMPERSAND

+ const Excellent1LexerCOMMA

+ const Excellent1LexerDECIMAL

+ const Excellent1LexerDIVIDE

+ const Excellent1LexerEQ

+ const Excellent1LexerERROR

+ const Excellent1LexerEXPONENT

+ const Excellent1LexerFALSE

+ const Excellent1LexerGT

+ const Excellent1LexerGTE

+ const Excellent1LexerLPAREN

+ const Excellent1LexerLT

+ const Excellent1LexerLTE

+ const Excellent1LexerMINUS

+ const Excellent1LexerNAME

+ const Excellent1LexerNEQ

+ const Excellent1LexerPLUS

+ const Excellent1LexerRPAREN

+ const Excellent1LexerSTRING

+ const Excellent1LexerTIMES

+ const Excellent1LexerTRUE

+ const Excellent1LexerWS

+ const Excellent1ParserAMPERSAND

+ const Excellent1ParserCOMMA

+ const Excellent1ParserDECIMAL

+ const Excellent1ParserDIVIDE

+ const Excellent1ParserEOF

+ const Excellent1ParserEQ

+ const Excellent1ParserERROR

+ const Excellent1ParserEXPONENT

+ const Excellent1ParserFALSE

+ const Excellent1ParserGT

+ const Excellent1ParserGTE

+ const Excellent1ParserLPAREN

+ const Excellent1ParserLT

+ const Excellent1ParserLTE

+ const Excellent1ParserMINUS

+ const Excellent1ParserNAME

+ const Excellent1ParserNEQ

+ const Excellent1ParserPLUS

+ const Excellent1ParserRPAREN

+ const Excellent1ParserRULE_expression

+ const Excellent1ParserRULE_fnname

+ const Excellent1ParserRULE_parameters

+ const Excellent1ParserRULE_parse

+ const Excellent1ParserSTRING

+ const Excellent1ParserTIMES

+ const Excellent1ParserTRUE

+ const Excellent1ParserWS

+ func Excellent1LexerInit()

+ func Excellent1ParserInit()

+ type AdditionOrSubtractionExpressionContext struct

+ func NewAdditionOrSubtractionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdditionOrSubtractionExpressionContext

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

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

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

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

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

+ func (s *AdditionOrSubtractionExpressionContext) GetOp() antlr.Token

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

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

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

+ func (s *AdditionOrSubtractionExpressionContext) SetOp(v antlr.Token)

+ type BaseExcellent1Listener struct

+ func (s *BaseExcellent1Listener) EnterAdditionOrSubtractionExpression(ctx *AdditionOrSubtractionExpressionContext)

+ func (s *BaseExcellent1Listener) EnterComparisonExpression(ctx *ComparisonExpressionContext)

+ func (s *BaseExcellent1Listener) EnterConcatenation(ctx *ConcatenationContext)

+ func (s *BaseExcellent1Listener) EnterContextReference(ctx *ContextReferenceContext)

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

+ func (s *BaseExcellent1Listener) EnterEqualityExpression(ctx *EqualityExpressionContext)

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

+ func (s *BaseExcellent1Listener) EnterExponentExpression(ctx *ExponentExpressionContext)

+ func (s *BaseExcellent1Listener) EnterFalse(ctx *FalseContext)

+ func (s *BaseExcellent1Listener) EnterFnname(ctx *FnnameContext)

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

+ func (s *BaseExcellent1Listener) EnterFunctionParameters(ctx *FunctionParametersContext)

+ func (s *BaseExcellent1Listener) EnterMultiplicationOrDivisionExpression(ctx *MultiplicationOrDivisionExpressionContext)

+ func (s *BaseExcellent1Listener) EnterNegation(ctx *NegationContext)

+ func (s *BaseExcellent1Listener) EnterParentheses(ctx *ParenthesesContext)

+ func (s *BaseExcellent1Listener) EnterParse(ctx *ParseContext)

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

+ func (s *BaseExcellent1Listener) EnterTrue(ctx *TrueContext)

+ func (s *BaseExcellent1Listener) ExitAdditionOrSubtractionExpression(ctx *AdditionOrSubtractionExpressionContext)

+ func (s *BaseExcellent1Listener) ExitComparisonExpression(ctx *ComparisonExpressionContext)

+ func (s *BaseExcellent1Listener) ExitConcatenation(ctx *ConcatenationContext)

+ func (s *BaseExcellent1Listener) ExitContextReference(ctx *ContextReferenceContext)

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

+ func (s *BaseExcellent1Listener) ExitEqualityExpression(ctx *EqualityExpressionContext)

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

+ func (s *BaseExcellent1Listener) ExitExponentExpression(ctx *ExponentExpressionContext)

+ func (s *BaseExcellent1Listener) ExitFalse(ctx *FalseContext)

+ func (s *BaseExcellent1Listener) ExitFnname(ctx *FnnameContext)

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

+ func (s *BaseExcellent1Listener) ExitFunctionParameters(ctx *FunctionParametersContext)

+ func (s *BaseExcellent1Listener) ExitMultiplicationOrDivisionExpression(ctx *MultiplicationOrDivisionExpressionContext)

+ func (s *BaseExcellent1Listener) ExitNegation(ctx *NegationContext)

+ func (s *BaseExcellent1Listener) ExitParentheses(ctx *ParenthesesContext)

+ func (s *BaseExcellent1Listener) ExitParse(ctx *ParseContext)

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

+ func (s *BaseExcellent1Listener) ExitTrue(ctx *TrueContext)

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

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

+ type BaseExcellent1Visitor struct

+ func (v *BaseExcellent1Visitor) VisitAdditionOrSubtractionExpression(ctx *AdditionOrSubtractionExpressionContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitComparisonExpression(ctx *ComparisonExpressionContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitConcatenation(ctx *ConcatenationContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitContextReference(ctx *ContextReferenceContext) interface{}

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

+ func (v *BaseExcellent1Visitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitExponentExpression(ctx *ExponentExpressionContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitFalse(ctx *FalseContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitFnname(ctx *FnnameContext) interface{}

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

+ func (v *BaseExcellent1Visitor) VisitFunctionParameters(ctx *FunctionParametersContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitMultiplicationOrDivisionExpression(ctx *MultiplicationOrDivisionExpressionContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitNegation(ctx *NegationContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitParentheses(ctx *ParenthesesContext) interface{}

+ func (v *BaseExcellent1Visitor) VisitParse(ctx *ParseContext) interface{}

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

+ func (v *BaseExcellent1Visitor) VisitTrue(ctx *TrueContext) interface{}

+ type ComparisonExpressionContext struct

+ func NewComparisonExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComparisonExpressionContext

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

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

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

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

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

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

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

+ func (s *ComparisonExpressionContext) GetOp() antlr.Token

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

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

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

+ func (s *ComparisonExpressionContext) SetOp(v antlr.Token)

+ type ConcatenationContext struct

+ func NewConcatenationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConcatenationContext

+ func (s *ConcatenationContext) AMPERSAND() antlr.TerminalNode

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

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

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

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

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

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

+ type ContextReferenceContext struct

+ func NewContextReferenceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ContextReferenceContext

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

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

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

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

+ func (s *ContextReferenceContext) NAME() antlr.TerminalNode

+ type DecimalLiteralContext struct

+ func NewDecimalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DecimalLiteralContext

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

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

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

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

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

+ type EqualityExpressionContext struct

+ func NewEqualityExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityExpressionContext

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

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

+ func (s *EqualityExpressionContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *EqualityExpressionContext) GetOp() antlr.Token

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

+ func (s *EqualityExpressionContext) NEQ() antlr.TerminalNode

+ func (s *EqualityExpressionContext) SetOp(v antlr.Token)

+ type Excellent1Lexer struct

+ func NewExcellent1Lexer(input antlr.CharStream) *Excellent1Lexer

+ type Excellent1Listener interface

+ EnterAdditionOrSubtractionExpression func(c *AdditionOrSubtractionExpressionContext)

+ EnterComparisonExpression func(c *ComparisonExpressionContext)

+ EnterConcatenation func(c *ConcatenationContext)

+ EnterContextReference func(c *ContextReferenceContext)

+ EnterDecimalLiteral func(c *DecimalLiteralContext)

+ EnterEqualityExpression func(c *EqualityExpressionContext)

+ EnterExponentExpression func(c *ExponentExpressionContext)

+ EnterFalse func(c *FalseContext)

+ EnterFnname func(c *FnnameContext)

+ EnterFunctionCall func(c *FunctionCallContext)

+ EnterFunctionParameters func(c *FunctionParametersContext)

+ EnterMultiplicationOrDivisionExpression func(c *MultiplicationOrDivisionExpressionContext)

+ EnterNegation func(c *NegationContext)

+ EnterParentheses func(c *ParenthesesContext)

+ EnterParse func(c *ParseContext)

+ EnterStringLiteral func(c *StringLiteralContext)

+ EnterTrue func(c *TrueContext)

+ ExitAdditionOrSubtractionExpression func(c *AdditionOrSubtractionExpressionContext)

+ ExitComparisonExpression func(c *ComparisonExpressionContext)

+ ExitConcatenation func(c *ConcatenationContext)

+ ExitContextReference func(c *ContextReferenceContext)

+ ExitDecimalLiteral func(c *DecimalLiteralContext)

+ ExitEqualityExpression func(c *EqualityExpressionContext)

+ ExitExponentExpression func(c *ExponentExpressionContext)

+ ExitFalse func(c *FalseContext)

+ ExitFnname func(c *FnnameContext)

+ ExitFunctionCall func(c *FunctionCallContext)

+ ExitFunctionParameters func(c *FunctionParametersContext)

+ ExitMultiplicationOrDivisionExpression func(c *MultiplicationOrDivisionExpressionContext)

+ ExitNegation func(c *NegationContext)

+ ExitParentheses func(c *ParenthesesContext)

+ ExitParse func(c *ParseContext)

+ ExitStringLiteral func(c *StringLiteralContext)

+ ExitTrue func(c *TrueContext)

+ type Excellent1Parser struct

+ func NewExcellent1Parser(input antlr.TokenStream) *Excellent1Parser

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

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

+ func (p *Excellent1Parser) Fnname() (localctx IFnnameContext)

+ func (p *Excellent1Parser) Parameters() (localctx IParametersContext)

+ func (p *Excellent1Parser) Parse() (localctx IParseContext)

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

+ type Excellent1Visitor interface

+ VisitAdditionOrSubtractionExpression func(ctx *AdditionOrSubtractionExpressionContext) interface{}

+ VisitComparisonExpression func(ctx *ComparisonExpressionContext) interface{}

+ VisitConcatenation func(ctx *ConcatenationContext) interface{}

+ VisitContextReference func(ctx *ContextReferenceContext) interface{}

+ VisitDecimalLiteral func(ctx *DecimalLiteralContext) interface{}

+ VisitEqualityExpression func(ctx *EqualityExpressionContext) interface{}

+ VisitExponentExpression func(ctx *ExponentExpressionContext) interface{}

+ VisitFalse func(ctx *FalseContext) interface{}

+ VisitFnname func(ctx *FnnameContext) interface{}

+ VisitFunctionCall func(ctx *FunctionCallContext) interface{}

+ VisitFunctionParameters func(ctx *FunctionParametersContext) interface{}

+ VisitMultiplicationOrDivisionExpression func(ctx *MultiplicationOrDivisionExpressionContext) interface{}

+ VisitNegation func(ctx *NegationContext) interface{}

+ VisitParentheses func(ctx *ParenthesesContext) interface{}

+ VisitParse func(ctx *ParseContext) interface{}

+ VisitStringLiteral func(ctx *StringLiteralContext) interface{}

+ VisitTrue func(ctx *TrueContext) interface{}

+ type ExponentExpressionContext struct

+ func NewExponentExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExponentExpressionContext

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

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

+ func (s *ExponentExpressionContext) EXPONENT() antlr.TerminalNode

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

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

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

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

+ type ExpressionContext struct

+ func NewEmptyExpressionContext() *ExpressionContext

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

+ func (*ExpressionContext) IsExpressionContext()

+ func (s *ExpressionContext) CopyFrom(ctx *ExpressionContext)

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

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

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

+ type FalseContext struct

+ func NewFalseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FalseContext

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

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

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

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

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

+ type FnnameContext struct

+ func NewEmptyFnnameContext() *FnnameContext

+ func NewFnnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnnameContext

+ func (*FnnameContext) IsFnnameContext()

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

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

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

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

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

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

+ func (s *FnnameContext) NAME() antlr.TerminalNode

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

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

+ type FunctionCallContext struct

+ func NewFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionCallContext

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

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

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

+ func (s *FunctionCallContext) Fnname() IFnnameContext

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

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

+ func (s *FunctionCallContext) Parameters() IParametersContext

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

+ type FunctionParametersContext struct

+ func NewFunctionParametersContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionParametersContext

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

+ func (s *FunctionParametersContext) AllCOMMA() []antlr.TerminalNode

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

+ func (s *FunctionParametersContext) COMMA(i int) antlr.TerminalNode

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

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

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

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

+ type IExpressionContext interface

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ type IFnnameContext interface

+ GetParser func() antlr.Parser

+ IsFnnameContext func()

+ type IParametersContext interface

+ GetParser func() antlr.Parser

+ IsParametersContext func()

+ type IParseContext interface

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ type MultiplicationOrDivisionExpressionContext struct

+ func NewMultiplicationOrDivisionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicationOrDivisionExpressionContext

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

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

+ func (s *MultiplicationOrDivisionExpressionContext) DIVIDE() antlr.TerminalNode

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

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

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

+ func (s *MultiplicationOrDivisionExpressionContext) GetOp() antlr.Token

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

+ func (s *MultiplicationOrDivisionExpressionContext) SetOp(v antlr.Token)

+ func (s *MultiplicationOrDivisionExpressionContext) TIMES() antlr.TerminalNode

+ type NegationContext struct

+ func NewNegationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NegationContext

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

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

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

+ func (s *NegationContext) Expression() IExpressionContext

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

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

+ type ParametersContext struct

+ func NewEmptyParametersContext() *ParametersContext

+ func NewParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParametersContext

+ func (*ParametersContext) IsParametersContext()

+ func (s *ParametersContext) CopyFrom(ctx *ParametersContext)

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

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

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

+ type ParenthesesContext struct

+ func NewParenthesesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesesContext

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

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

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

+ func (s *ParenthesesContext) Expression() IExpressionContext

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

+ func (s *ParenthesesContext) LPAREN() antlr.TerminalNode

+ func (s *ParenthesesContext) RPAREN() antlr.TerminalNode

+ type ParseContext struct

+ func NewEmptyParseContext() *ParseContext

+ func NewParseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParseContext

+ func (*ParseContext) IsParseContext()

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

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

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

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

+ func (s *ParseContext) Expression() IExpressionContext

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

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

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

+ type StringLiteralContext struct

+ func NewStringLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringLiteralContext

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

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

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

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

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

+ type TrueContext struct

+ func NewTrueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TrueContext

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

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

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

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

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