gen

package

Go to main page

Versions in this module

v0

v0.30.0

Jul 31, 2026

Changes in this version

+ const CELLexerESC_IDENTIFIER

+ const CELParserESC_IDENTIFIER

+ const CELParserRULE_escapeIdent

+ func InitEmptyEscapeIdentContext(p *EscapeIdentContext)

type BaseCELListener

+ func (s *BaseCELListener) EnterEscapedIdentifier(ctx *EscapedIdentifierContext)

+ func (s *BaseCELListener) EnterGlobalCall(ctx *GlobalCallContext)

+ func (s *BaseCELListener) EnterIdent(ctx *IdentContext)

+ func (s *BaseCELListener) EnterSimpleIdentifier(ctx *SimpleIdentifierContext)

+ func (s *BaseCELListener) ExitEscapedIdentifier(ctx *EscapedIdentifierContext)

+ func (s *BaseCELListener) ExitGlobalCall(ctx *GlobalCallContext)

+ func (s *BaseCELListener) ExitIdent(ctx *IdentContext)

+ func (s *BaseCELListener) ExitSimpleIdentifier(ctx *SimpleIdentifierContext)

type BaseCELVisitor

+ func (v *BaseCELVisitor) VisitEscapedIdentifier(ctx *EscapedIdentifierContext) interface{}

+ func (v *BaseCELVisitor) VisitGlobalCall(ctx *GlobalCallContext) interface{}

+ func (v *BaseCELVisitor) VisitIdent(ctx *IdentContext) interface{}

+ func (v *BaseCELVisitor) VisitSimpleIdentifier(ctx *SimpleIdentifierContext) interface{}

type CELListener

+ EnterEscapedIdentifier func(c *EscapedIdentifierContext)

+ EnterGlobalCall func(c *GlobalCallContext)

+ EnterIdent func(c *IdentContext)

+ EnterSimpleIdentifier func(c *SimpleIdentifierContext)

+ ExitEscapedIdentifier func(c *EscapedIdentifierContext)

+ ExitGlobalCall func(c *GlobalCallContext)

+ ExitIdent func(c *IdentContext)

+ ExitSimpleIdentifier func(c *SimpleIdentifierContext)

type CELParser

+ func (p *CELParser) EscapeIdent() (localctx IEscapeIdentContext)

type CELVisitor

+ VisitEscapedIdentifier func(ctx *EscapedIdentifierContext) interface{}

+ VisitGlobalCall func(ctx *GlobalCallContext) interface{}

+ VisitIdent func(ctx *IdentContext) interface{}

+ VisitSimpleIdentifier func(ctx *SimpleIdentifierContext) interface{}

+ type EscapeIdentContext struct

+ func NewEmptyEscapeIdentContext() *EscapeIdentContext

+ func NewEscapeIdentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EscapeIdentContext

+ func (*EscapeIdentContext) IsEscapeIdentContext()

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

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

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

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

+ type EscapedIdentifierContext struct

+ func NewEscapedIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EscapedIdentifierContext

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

+ func (s *EscapedIdentifierContext) ESC_IDENTIFIER() antlr.TerminalNode

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

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

+ func (s *EscapedIdentifierContext) GetId() antlr.Token

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

+ func (s *EscapedIdentifierContext) SetId(v antlr.Token)

+ type GlobalCallContext struct

+ func NewGlobalCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GlobalCallContext

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

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

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

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

+ func (s *GlobalCallContext) ExprList() IExprListContext

+ func (s *GlobalCallContext) GetArgs() IExprListContext

+ func (s *GlobalCallContext) GetId() antlr.Token

+ func (s *GlobalCallContext) GetLeadingDot() antlr.Token

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

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

+ func (s *GlobalCallContext) IDENTIFIER() antlr.TerminalNode

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

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

+ func (s *GlobalCallContext) SetArgs(v IExprListContext)

+ func (s *GlobalCallContext) SetId(v antlr.Token)

+ func (s *GlobalCallContext) SetLeadingDot(v antlr.Token)

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

+ type IEscapeIdentContext interface

+ GetParser func() antlr.Parser

+ IsEscapeIdentContext func()

type IOptFieldContext

+ EscapeIdent func() IEscapeIdentContext

+ type IdentContext struct

+ func NewIdentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentContext

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

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

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

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

+ func (s *IdentContext) GetId() antlr.Token

+ func (s *IdentContext) GetLeadingDot() antlr.Token

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

+ func (s *IdentContext) IDENTIFIER() antlr.TerminalNode

+ func (s *IdentContext) SetId(v antlr.Token)

+ func (s *IdentContext) SetLeadingDot(v antlr.Token)

type OptFieldContext

+ func (s *OptFieldContext) EscapeIdent() IEscapeIdentContext

type SelectContext

+ func (s *SelectContext) EscapeIdent() IEscapeIdentContext

+ type SimpleIdentifierContext struct

+ func NewSimpleIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleIdentifierContext

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

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

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

+ func (s *SimpleIdentifierContext) GetId() antlr.Token

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

+ func (s *SimpleIdentifierContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SimpleIdentifierContext) SetId(v antlr.Token)

v0.20.2

May 2, 2024

Changes in this version

+ var CELLexerLexerStaticData struct

+ var CELParserStaticData struct

+ func InitEmptyCalcContext(p *CalcContext)

+ func InitEmptyConditionalAndContext(p *ConditionalAndContext)

+ func InitEmptyConditionalOrContext(p *ConditionalOrContext)

+ func InitEmptyExprContext(p *ExprContext)

+ func InitEmptyExprListContext(p *ExprListContext)

+ func InitEmptyFieldInitializerListContext(p *FieldInitializerListContext)

+ func InitEmptyListInitContext(p *ListInitContext)

+ func InitEmptyLiteralContext(p *LiteralContext)

+ func InitEmptyMapInitializerListContext(p *MapInitializerListContext)

+ func InitEmptyMemberContext(p *MemberContext)

+ func InitEmptyOptExprContext(p *OptExprContext)

+ func InitEmptyOptFieldContext(p *OptFieldContext)

+ func InitEmptyPrimaryContext(p *PrimaryContext)

+ func InitEmptyRelationContext(p *RelationContext)

+ func InitEmptyStartContext(p *StartContext)

+ func InitEmptyUnaryContext(p *UnaryContext)

type CELParser

+ func (p *CELParser) Start_() (localctx IStartContext)

type LiteralContext

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

type MemberContext

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

type PrimaryContext

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

type UnaryContext

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

v0.17.5

Aug 21, 2023

v0.17.4

Aug 21, 2023

v0.17.3

Aug 21, 2023

Changes in this version

+ const CELLexerCEL_FALSE

+ const CELLexerCEL_TRUE

+ const CELLexerIN

+ const CELLexerNUL

+ const CELParserCEL_FALSE

+ const CELParserCEL_TRUE

+ const CELParserIN

+ const CELParserNUL

+ const CELParserRULE_listInit

+ const CELParserRULE_optExpr

+ const CELParserRULE_optField

+ func CELLexerInit()

+ func CELParserInit()

type BaseCELListener

+ func (s *BaseCELListener) EnterListInit(ctx *ListInitContext)

+ func (s *BaseCELListener) EnterMemberCall(ctx *MemberCallContext)

+ func (s *BaseCELListener) EnterOptExpr(ctx *OptExprContext)

+ func (s *BaseCELListener) EnterOptField(ctx *OptFieldContext)

+ func (s *BaseCELListener) EnterSelect(ctx *SelectContext)

+ func (s *BaseCELListener) ExitListInit(ctx *ListInitContext)

+ func (s *BaseCELListener) ExitMemberCall(ctx *MemberCallContext)

+ func (s *BaseCELListener) ExitOptExpr(ctx *OptExprContext)

+ func (s *BaseCELListener) ExitOptField(ctx *OptFieldContext)

+ func (s *BaseCELListener) ExitSelect(ctx *SelectContext)

type BaseCELVisitor

+ func (v *BaseCELVisitor) VisitListInit(ctx *ListInitContext) interface{}

+ func (v *BaseCELVisitor) VisitMemberCall(ctx *MemberCallContext) interface{}

+ func (v *BaseCELVisitor) VisitOptExpr(ctx *OptExprContext) interface{}

+ func (v *BaseCELVisitor) VisitOptField(ctx *OptFieldContext) interface{}

+ func (v *BaseCELVisitor) VisitSelect(ctx *SelectContext) interface{}

type BoolFalseContext

+ func (s *BoolFalseContext) CEL_FALSE() antlr.TerminalNode

type BoolTrueContext

+ func (s *BoolTrueContext) CEL_TRUE() antlr.TerminalNode

type CELListener

+ EnterListInit func(c *ListInitContext)

+ EnterMemberCall func(c *MemberCallContext)

+ EnterOptExpr func(c *OptExprContext)

+ EnterOptField func(c *OptFieldContext)

+ EnterSelect func(c *SelectContext)

+ ExitListInit func(c *ListInitContext)

+ ExitMemberCall func(c *MemberCallContext)

+ ExitOptExpr func(c *OptExprContext)

+ ExitOptField func(c *OptFieldContext)

+ ExitSelect func(c *SelectContext)

type CELParser

+ func (p *CELParser) ListInit() (localctx IListInitContext)

+ func (p *CELParser) OptExpr() (localctx IOptExprContext)

+ func (p *CELParser) OptField() (localctx IOptFieldContext)

type CELVisitor

+ VisitListInit func(ctx *ListInitContext) interface{}

+ VisitMemberCall func(ctx *MemberCallContext) interface{}

+ VisitOptExpr func(ctx *OptExprContext) interface{}

+ VisitOptField func(ctx *OptFieldContext) interface{}

+ VisitSelect func(ctx *SelectContext) interface{}

type CalcContext

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

+ func (s *CalcContext) PERCENT() antlr.TerminalNode

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

+ func (s *CalcContext) SLASH() antlr.TerminalNode

+ func (s *CalcContext) STAR() antlr.TerminalNode

type ConditionalAndContext

+ func (s *ConditionalAndContext) AllLOGICAL_AND() []antlr.TerminalNode

+ func (s *ConditionalAndContext) LOGICAL_AND(i int) antlr.TerminalNode

type ConditionalOrContext

+ func (s *ConditionalOrContext) AllLOGICAL_OR() []antlr.TerminalNode

+ func (s *ConditionalOrContext) LOGICAL_OR(i int) antlr.TerminalNode

type CreateListContext

+ func (s *CreateListContext) COMMA() antlr.TerminalNode

+ func (s *CreateListContext) LBRACKET() antlr.TerminalNode

+ func (s *CreateListContext) ListInit() IListInitContext

+ func (s *CreateListContext) RPRACKET() antlr.TerminalNode

type CreateMessageContext

+ func (s *CreateMessageContext) AllDOT() []antlr.TerminalNode

+ func (s *CreateMessageContext) AllIDENTIFIER() []antlr.TerminalNode

+ func (s *CreateMessageContext) COMMA() antlr.TerminalNode

+ func (s *CreateMessageContext) DOT(i int) antlr.TerminalNode

+ func (s *CreateMessageContext) GetIds() []antlr.Token

+ func (s *CreateMessageContext) GetLeadingDot() antlr.Token

+ func (s *CreateMessageContext) GetOps() []antlr.Token

+ func (s *CreateMessageContext) GetS16() antlr.Token

+ func (s *CreateMessageContext) Get_IDENTIFIER() antlr.Token

+ func (s *CreateMessageContext) IDENTIFIER(i int) antlr.TerminalNode

+ func (s *CreateMessageContext) LBRACE() antlr.TerminalNode

+ func (s *CreateMessageContext) RBRACE() antlr.TerminalNode

+ func (s *CreateMessageContext) SetIds(v []antlr.Token)

+ func (s *CreateMessageContext) SetLeadingDot(v antlr.Token)

+ func (s *CreateMessageContext) SetOps(v []antlr.Token)

+ func (s *CreateMessageContext) SetS16(v antlr.Token)

+ func (s *CreateMessageContext) Set_IDENTIFIER(v antlr.Token)

type CreateStructContext

+ func (s *CreateStructContext) COMMA() antlr.TerminalNode

+ func (s *CreateStructContext) LBRACE() antlr.TerminalNode

+ func (s *CreateStructContext) RBRACE() antlr.TerminalNode

type ExprContext

+ func (s *ExprContext) COLON() antlr.TerminalNode

+ func (s *ExprContext) QUESTIONMARK() antlr.TerminalNode

type ExprListContext

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

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

type FieldInitializerListContext

+ func (s *FieldInitializerListContext) AllCOLON() []antlr.TerminalNode

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

+ func (s *FieldInitializerListContext) AllOptField() []IOptFieldContext

+ func (s *FieldInitializerListContext) COLON(i int) antlr.TerminalNode

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

+ func (s *FieldInitializerListContext) Get_optField() IOptFieldContext

+ func (s *FieldInitializerListContext) OptField(i int) IOptFieldContext

+ func (s *FieldInitializerListContext) Set_optField(v IOptFieldContext)

type ICalcContext

+ AllCalc func() []ICalcContext

+ Calc func(i int) ICalcContext

+ MINUS func() antlr.TerminalNode

+ PERCENT func() antlr.TerminalNode

+ PLUS func() antlr.TerminalNode

+ SLASH func() antlr.TerminalNode

+ STAR func() antlr.TerminalNode

+ Unary func() IUnaryContext

type IConditionalAndContext

+ AllLOGICAL_AND func() []antlr.TerminalNode

+ AllRelation func() []IRelationContext

+ LOGICAL_AND func(i int) antlr.TerminalNode

+ Relation func(i int) IRelationContext

type IConditionalOrContext

+ AllConditionalAnd func() []IConditionalAndContext

+ AllLOGICAL_OR func() []antlr.TerminalNode

+ ConditionalAnd func(i int) IConditionalAndContext

+ LOGICAL_OR func(i int) antlr.TerminalNode

type IExprContext

+ AllConditionalOr func() []IConditionalOrContext

+ COLON func() antlr.TerminalNode

+ ConditionalOr func(i int) IConditionalOrContext

+ Expr func() IExprContext

+ QUESTIONMARK func() antlr.TerminalNode

type IExprListContext

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

type IFieldInitializerListContext

+ AllCOLON func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllOptField func() []IOptFieldContext

+ COLON func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Get_optField func() IOptFieldContext

+ OptField func(i int) IOptFieldContext

+ Set_optField func(IOptFieldContext)

+ type IListInitContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllOptExpr func() []IOptExprContext

+ COMMA func(i int) antlr.TerminalNode

+ GetElems func() []IOptExprContext

+ GetParser func() antlr.Parser

+ Get_optExpr func() IOptExprContext

+ IsListInitContext func()

+ OptExpr func(i int) IOptExprContext

+ SetElems func([]IOptExprContext)

+ Set_optExpr func(IOptExprContext)

type IMapInitializerListContext

+ AllCOLON func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllOptExpr func() []IOptExprContext

+ COLON func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Get_optExpr func() IOptExprContext

+ OptExpr func(i int) IOptExprContext

+ Set_optExpr func(IOptExprContext)

+ type IOptExprContext interface

+ Expr func() IExprContext

+ GetE func() IExprContext

+ GetOpt func() antlr.Token

+ GetParser func() antlr.Parser

+ IsOptExprContext func()

+ QUESTIONMARK func() antlr.TerminalNode

+ SetE func(IExprContext)

+ SetOpt func(antlr.Token)

+ type IOptFieldContext interface

+ GetOpt func() antlr.Token

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsOptFieldContext func()

+ QUESTIONMARK func() antlr.TerminalNode

+ SetOpt func(antlr.Token)

type IRelationContext

+ AllRelation func() []IRelationContext

+ Calc func() ICalcContext

+ EQUALS func() antlr.TerminalNode

+ GREATER func() antlr.TerminalNode

+ GREATER_EQUALS func() antlr.TerminalNode

+ IN func() antlr.TerminalNode

+ LESS func() antlr.TerminalNode

+ LESS_EQUALS func() antlr.TerminalNode

+ NOT_EQUALS func() antlr.TerminalNode

+ Relation func(i int) IRelationContext

type IStartContext

+ EOF func() antlr.TerminalNode

+ Expr func() IExprContext

type IdentOrGlobalCallContext

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

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

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

type IndexContext

+ func (s *IndexContext) GetOpt() antlr.Token

+ func (s *IndexContext) LBRACKET() antlr.TerminalNode

+ func (s *IndexContext) QUESTIONMARK() antlr.TerminalNode

+ func (s *IndexContext) RPRACKET() antlr.TerminalNode

+ func (s *IndexContext) SetOpt(v antlr.Token)

+ type ListInitContext struct

+ func NewEmptyListInitContext() *ListInitContext

+ func NewListInitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListInitContext

+ func (*ListInitContext) IsListInitContext()

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

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

+ func (s *ListInitContext) AllOptExpr() []IOptExprContext

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

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

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

+ func (s *ListInitContext) GetElems() []IOptExprContext

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

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

+ func (s *ListInitContext) Get_optExpr() IOptExprContext

+ func (s *ListInitContext) OptExpr(i int) IOptExprContext

+ func (s *ListInitContext) SetElems(v []IOptExprContext)

+ func (s *ListInitContext) Set_optExpr(v IOptExprContext)

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

type LogicalNotContext

+ func (s *LogicalNotContext) AllEXCLAM() []antlr.TerminalNode

+ func (s *LogicalNotContext) EXCLAM(i int) antlr.TerminalNode

type MapInitializerListContext

+ func (s *MapInitializerListContext) AllCOLON() []antlr.TerminalNode

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

+ func (s *MapInitializerListContext) AllOptExpr() []IOptExprContext

+ func (s *MapInitializerListContext) COLON(i int) antlr.TerminalNode

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

+ func (s *MapInitializerListContext) Get_optExpr() IOptExprContext

+ func (s *MapInitializerListContext) OptExpr(i int) IOptExprContext

+ func (s *MapInitializerListContext) Set_optExpr(v IOptExprContext)

+ type MemberCallContext struct

+ func NewMemberCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberCallContext

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

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

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

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

+ func (s *MemberCallContext) ExprList() IExprListContext

+ func (s *MemberCallContext) GetArgs() IExprListContext

+ func (s *MemberCallContext) GetId() antlr.Token

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

+ func (s *MemberCallContext) GetOpen() antlr.Token

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

+ func (s *MemberCallContext) IDENTIFIER() antlr.TerminalNode

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

+ func (s *MemberCallContext) Member() IMemberContext

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

+ func (s *MemberCallContext) SetArgs(v IExprListContext)

+ func (s *MemberCallContext) SetId(v antlr.Token)

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

+ func (s *MemberCallContext) SetOpen(v antlr.Token)

type NegateContext

+ func (s *NegateContext) AllMINUS() []antlr.TerminalNode

+ func (s *NegateContext) MINUS(i int) antlr.TerminalNode

type NestedContext

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

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

type NullContext

+ func (s *NullContext) NUL() antlr.TerminalNode

+ type OptExprContext struct

+ func NewEmptyOptExprContext() *OptExprContext

+ func NewOptExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptExprContext

+ func (*OptExprContext) IsOptExprContext()

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

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

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

+ func (s *OptExprContext) Expr() IExprContext

+ func (s *OptExprContext) GetE() IExprContext

+ func (s *OptExprContext) GetOpt() antlr.Token

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

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

+ func (s *OptExprContext) QUESTIONMARK() antlr.TerminalNode

+ func (s *OptExprContext) SetE(v IExprContext)

+ func (s *OptExprContext) SetOpt(v antlr.Token)

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

+ type OptFieldContext struct

+ func NewEmptyOptFieldContext() *OptFieldContext

+ func NewOptFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptFieldContext

+ func (*OptFieldContext) IsOptFieldContext()

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

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

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

+ func (s *OptFieldContext) GetOpt() antlr.Token

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

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

+ func (s *OptFieldContext) IDENTIFIER() antlr.TerminalNode

+ func (s *OptFieldContext) QUESTIONMARK() antlr.TerminalNode

+ func (s *OptFieldContext) SetOpt(v antlr.Token)

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

type RelationContext

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

+ func (s *RelationContext) GREATER() antlr.TerminalNode

+ func (s *RelationContext) GREATER_EQUALS() antlr.TerminalNode

+ func (s *RelationContext) IN() antlr.TerminalNode

+ func (s *RelationContext) LESS() antlr.TerminalNode

+ func (s *RelationContext) LESS_EQUALS() antlr.TerminalNode

+ func (s *RelationContext) NOT_EQUALS() antlr.TerminalNode

+ type SelectContext struct

+ func NewSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectContext

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

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

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

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

+ func (s *SelectContext) GetId() antlr.Token

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

+ func (s *SelectContext) GetOpt() antlr.Token

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

+ func (s *SelectContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SelectContext) Member() IMemberContext

+ func (s *SelectContext) QUESTIONMARK() antlr.TerminalNode

+ func (s *SelectContext) SetId(v antlr.Token)

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

+ func (s *SelectContext) SetOpt(v antlr.Token)

v0.1.0

Feb 5, 2019

Changes in this version

+ const CELLexerBYTES

+ const CELLexerCOLON

+ const CELLexerCOMMA

+ const CELLexerCOMMENT

+ const CELLexerDOT

+ const CELLexerEQUALS

+ const CELLexerEXCLAM

+ const CELLexerFALSE

+ const CELLexerGREATER

+ const CELLexerGREATER_EQUALS

+ const CELLexerIDENTIFIER

+ const CELLexerLBRACE

+ const CELLexerLBRACKET

+ const CELLexerLESS

+ const CELLexerLESS_EQUALS

+ const CELLexerLOGICAL_AND

+ const CELLexerLOGICAL_OR

+ const CELLexerLPAREN

+ const CELLexerMINUS

+ const CELLexerNOT_EQUALS

+ const CELLexerNULL

+ const CELLexerNUM_FLOAT

+ const CELLexerNUM_INT

+ const CELLexerNUM_UINT

+ const CELLexerPERCENT

+ const CELLexerPLUS

+ const CELLexerQUESTIONMARK

+ const CELLexerRBRACE

+ const CELLexerRPAREN

+ const CELLexerRPRACKET

+ const CELLexerSLASH

+ const CELLexerSTAR

+ const CELLexerSTRING

+ const CELLexerTRUE

+ const CELLexerT__0

+ const CELLexerWHITESPACE

+ const CELParserBYTES

+ const CELParserCOLON

+ const CELParserCOMMA

+ const CELParserCOMMENT

+ const CELParserDOT

+ const CELParserEOF

+ const CELParserEQUALS

+ const CELParserEXCLAM

+ const CELParserFALSE

+ const CELParserGREATER

+ const CELParserGREATER_EQUALS

+ const CELParserIDENTIFIER

+ const CELParserLBRACE

+ const CELParserLBRACKET

+ const CELParserLESS

+ const CELParserLESS_EQUALS

+ const CELParserLOGICAL_AND

+ const CELParserLOGICAL_OR

+ const CELParserLPAREN

+ const CELParserMINUS

+ const CELParserNOT_EQUALS

+ const CELParserNULL

+ const CELParserNUM_FLOAT

+ const CELParserNUM_INT

+ const CELParserNUM_UINT

+ const CELParserPERCENT

+ const CELParserPLUS

+ const CELParserQUESTIONMARK

+ const CELParserRBRACE

+ const CELParserRPAREN

+ const CELParserRPRACKET

+ const CELParserRULE_calc

+ const CELParserRULE_conditionalAnd

+ const CELParserRULE_conditionalOr

+ const CELParserRULE_expr

+ const CELParserRULE_exprList

+ const CELParserRULE_fieldInitializerList

+ const CELParserRULE_literal

+ const CELParserRULE_mapInitializerList

+ const CELParserRULE_member

+ const CELParserRULE_primary

+ const CELParserRULE_relation

+ const CELParserRULE_start

+ const CELParserRULE_unary

+ const CELParserSLASH

+ const CELParserSTAR

+ const CELParserSTRING

+ const CELParserTRUE

+ const CELParserT__0

+ const CELParserWHITESPACE

+ type BaseCELListener struct

+ func (s *BaseCELListener) EnterBoolFalse(ctx *BoolFalseContext)

+ func (s *BaseCELListener) EnterBoolTrue(ctx *BoolTrueContext)

+ func (s *BaseCELListener) EnterBytes(ctx *BytesContext)

+ func (s *BaseCELListener) EnterCalc(ctx *CalcContext)

+ func (s *BaseCELListener) EnterConditionalAnd(ctx *ConditionalAndContext)

+ func (s *BaseCELListener) EnterConditionalOr(ctx *ConditionalOrContext)

+ func (s *BaseCELListener) EnterConstantLiteral(ctx *ConstantLiteralContext)

+ func (s *BaseCELListener) EnterCreateList(ctx *CreateListContext)

+ func (s *BaseCELListener) EnterCreateMessage(ctx *CreateMessageContext)

+ func (s *BaseCELListener) EnterCreateStruct(ctx *CreateStructContext)

+ func (s *BaseCELListener) EnterDouble(ctx *DoubleContext)

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

+ func (s *BaseCELListener) EnterExpr(ctx *ExprContext)

+ func (s *BaseCELListener) EnterExprList(ctx *ExprListContext)

+ func (s *BaseCELListener) EnterFieldInitializerList(ctx *FieldInitializerListContext)

+ func (s *BaseCELListener) EnterIdentOrGlobalCall(ctx *IdentOrGlobalCallContext)

+ func (s *BaseCELListener) EnterIndex(ctx *IndexContext)

+ func (s *BaseCELListener) EnterInt(ctx *IntContext)

+ func (s *BaseCELListener) EnterLogicalNot(ctx *LogicalNotContext)

+ func (s *BaseCELListener) EnterMapInitializerList(ctx *MapInitializerListContext)

+ func (s *BaseCELListener) EnterMemberExpr(ctx *MemberExprContext)

+ func (s *BaseCELListener) EnterNegate(ctx *NegateContext)

+ func (s *BaseCELListener) EnterNested(ctx *NestedContext)

+ func (s *BaseCELListener) EnterNull(ctx *NullContext)

+ func (s *BaseCELListener) EnterPrimaryExpr(ctx *PrimaryExprContext)

+ func (s *BaseCELListener) EnterRelation(ctx *RelationContext)

+ func (s *BaseCELListener) EnterSelectOrCall(ctx *SelectOrCallContext)

+ func (s *BaseCELListener) EnterStart(ctx *StartContext)

+ func (s *BaseCELListener) EnterString(ctx *StringContext)

+ func (s *BaseCELListener) EnterUint(ctx *UintContext)

+ func (s *BaseCELListener) ExitBoolFalse(ctx *BoolFalseContext)

+ func (s *BaseCELListener) ExitBoolTrue(ctx *BoolTrueContext)

+ func (s *BaseCELListener) ExitBytes(ctx *BytesContext)

+ func (s *BaseCELListener) ExitCalc(ctx *CalcContext)

+ func (s *BaseCELListener) ExitConditionalAnd(ctx *ConditionalAndContext)

+ func (s *BaseCELListener) ExitConditionalOr(ctx *ConditionalOrContext)

+ func (s *BaseCELListener) ExitConstantLiteral(ctx *ConstantLiteralContext)

+ func (s *BaseCELListener) ExitCreateList(ctx *CreateListContext)

+ func (s *BaseCELListener) ExitCreateMessage(ctx *CreateMessageContext)

+ func (s *BaseCELListener) ExitCreateStruct(ctx *CreateStructContext)

+ func (s *BaseCELListener) ExitDouble(ctx *DoubleContext)

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

+ func (s *BaseCELListener) ExitExpr(ctx *ExprContext)

+ func (s *BaseCELListener) ExitExprList(ctx *ExprListContext)

+ func (s *BaseCELListener) ExitFieldInitializerList(ctx *FieldInitializerListContext)

+ func (s *BaseCELListener) ExitIdentOrGlobalCall(ctx *IdentOrGlobalCallContext)

+ func (s *BaseCELListener) ExitIndex(ctx *IndexContext)

+ func (s *BaseCELListener) ExitInt(ctx *IntContext)

+ func (s *BaseCELListener) ExitLogicalNot(ctx *LogicalNotContext)

+ func (s *BaseCELListener) ExitMapInitializerList(ctx *MapInitializerListContext)

+ func (s *BaseCELListener) ExitMemberExpr(ctx *MemberExprContext)

+ func (s *BaseCELListener) ExitNegate(ctx *NegateContext)

+ func (s *BaseCELListener) ExitNested(ctx *NestedContext)

+ func (s *BaseCELListener) ExitNull(ctx *NullContext)

+ func (s *BaseCELListener) ExitPrimaryExpr(ctx *PrimaryExprContext)

+ func (s *BaseCELListener) ExitRelation(ctx *RelationContext)

+ func (s *BaseCELListener) ExitSelectOrCall(ctx *SelectOrCallContext)

+ func (s *BaseCELListener) ExitStart(ctx *StartContext)

+ func (s *BaseCELListener) ExitString(ctx *StringContext)

+ func (s *BaseCELListener) ExitUint(ctx *UintContext)

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

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

+ type BaseCELVisitor struct

+ func (v *BaseCELVisitor) VisitBoolFalse(ctx *BoolFalseContext) interface{}

+ func (v *BaseCELVisitor) VisitBoolTrue(ctx *BoolTrueContext) interface{}

+ func (v *BaseCELVisitor) VisitBytes(ctx *BytesContext) interface{}

+ func (v *BaseCELVisitor) VisitCalc(ctx *CalcContext) interface{}

+ func (v *BaseCELVisitor) VisitConditionalAnd(ctx *ConditionalAndContext) interface{}

+ func (v *BaseCELVisitor) VisitConditionalOr(ctx *ConditionalOrContext) interface{}

+ func (v *BaseCELVisitor) VisitConstantLiteral(ctx *ConstantLiteralContext) interface{}

+ func (v *BaseCELVisitor) VisitCreateList(ctx *CreateListContext) interface{}

+ func (v *BaseCELVisitor) VisitCreateMessage(ctx *CreateMessageContext) interface{}

+ func (v *BaseCELVisitor) VisitCreateStruct(ctx *CreateStructContext) interface{}

+ func (v *BaseCELVisitor) VisitDouble(ctx *DoubleContext) interface{}

+ func (v *BaseCELVisitor) VisitExpr(ctx *ExprContext) interface{}

+ func (v *BaseCELVisitor) VisitExprList(ctx *ExprListContext) interface{}

+ func (v *BaseCELVisitor) VisitFieldInitializerList(ctx *FieldInitializerListContext) interface{}

+ func (v *BaseCELVisitor) VisitIdentOrGlobalCall(ctx *IdentOrGlobalCallContext) interface{}

+ func (v *BaseCELVisitor) VisitIndex(ctx *IndexContext) interface{}

+ func (v *BaseCELVisitor) VisitInt(ctx *IntContext) interface{}

+ func (v *BaseCELVisitor) VisitLogicalNot(ctx *LogicalNotContext) interface{}

+ func (v *BaseCELVisitor) VisitMapInitializerList(ctx *MapInitializerListContext) interface{}

+ func (v *BaseCELVisitor) VisitMemberExpr(ctx *MemberExprContext) interface{}

+ func (v *BaseCELVisitor) VisitNegate(ctx *NegateContext) interface{}

+ func (v *BaseCELVisitor) VisitNested(ctx *NestedContext) interface{}

+ func (v *BaseCELVisitor) VisitNull(ctx *NullContext) interface{}

+ func (v *BaseCELVisitor) VisitPrimaryExpr(ctx *PrimaryExprContext) interface{}

+ func (v *BaseCELVisitor) VisitRelation(ctx *RelationContext) interface{}

+ func (v *BaseCELVisitor) VisitSelectOrCall(ctx *SelectOrCallContext) interface{}

+ func (v *BaseCELVisitor) VisitStart(ctx *StartContext) interface{}

+ func (v *BaseCELVisitor) VisitString(ctx *StringContext) interface{}

+ func (v *BaseCELVisitor) VisitUint(ctx *UintContext) interface{}

+ type BoolFalseContext struct

+ func NewBoolFalseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolFalseContext

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

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

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

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

+ func (s *BoolFalseContext) GetTok() antlr.Token

+ func (s *BoolFalseContext) SetTok(v antlr.Token)

+ type BoolTrueContext struct

+ func NewBoolTrueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolTrueContext

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

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

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

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

+ func (s *BoolTrueContext) GetTok() antlr.Token

+ func (s *BoolTrueContext) SetTok(v antlr.Token)

+ type BytesContext struct

+ func NewBytesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BytesContext

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

+ func (s *BytesContext) BYTES() antlr.TerminalNode

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

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

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

+ func (s *BytesContext) GetTok() antlr.Token

+ func (s *BytesContext) SetTok(v antlr.Token)

+ type CELLexer struct

+ func NewCELLexer(input antlr.CharStream) *CELLexer

+ type CELListener interface

+ EnterBoolFalse func(c *BoolFalseContext)

+ EnterBoolTrue func(c *BoolTrueContext)

+ EnterBytes func(c *BytesContext)

+ EnterCalc func(c *CalcContext)

+ EnterConditionalAnd func(c *ConditionalAndContext)

+ EnterConditionalOr func(c *ConditionalOrContext)

+ EnterConstantLiteral func(c *ConstantLiteralContext)

+ EnterCreateList func(c *CreateListContext)

+ EnterCreateMessage func(c *CreateMessageContext)

+ EnterCreateStruct func(c *CreateStructContext)

+ EnterDouble func(c *DoubleContext)

+ EnterExpr func(c *ExprContext)

+ EnterExprList func(c *ExprListContext)

+ EnterFieldInitializerList func(c *FieldInitializerListContext)

+ EnterIdentOrGlobalCall func(c *IdentOrGlobalCallContext)

+ EnterIndex func(c *IndexContext)

+ EnterInt func(c *IntContext)

+ EnterLogicalNot func(c *LogicalNotContext)

+ EnterMapInitializerList func(c *MapInitializerListContext)

+ EnterMemberExpr func(c *MemberExprContext)

+ EnterNegate func(c *NegateContext)

+ EnterNested func(c *NestedContext)

+ EnterNull func(c *NullContext)

+ EnterPrimaryExpr func(c *PrimaryExprContext)

+ EnterRelation func(c *RelationContext)

+ EnterSelectOrCall func(c *SelectOrCallContext)

+ EnterStart func(c *StartContext)

+ EnterString func(c *StringContext)

+ EnterUint func(c *UintContext)

+ ExitBoolFalse func(c *BoolFalseContext)

+ ExitBoolTrue func(c *BoolTrueContext)

+ ExitBytes func(c *BytesContext)

+ ExitCalc func(c *CalcContext)

+ ExitConditionalAnd func(c *ConditionalAndContext)

+ ExitConditionalOr func(c *ConditionalOrContext)

+ ExitConstantLiteral func(c *ConstantLiteralContext)

+ ExitCreateList func(c *CreateListContext)

+ ExitCreateMessage func(c *CreateMessageContext)

+ ExitCreateStruct func(c *CreateStructContext)

+ ExitDouble func(c *DoubleContext)

+ ExitExpr func(c *ExprContext)

+ ExitExprList func(c *ExprListContext)

+ ExitFieldInitializerList func(c *FieldInitializerListContext)

+ ExitIdentOrGlobalCall func(c *IdentOrGlobalCallContext)

+ ExitIndex func(c *IndexContext)

+ ExitInt func(c *IntContext)

+ ExitLogicalNot func(c *LogicalNotContext)

+ ExitMapInitializerList func(c *MapInitializerListContext)

+ ExitMemberExpr func(c *MemberExprContext)

+ ExitNegate func(c *NegateContext)

+ ExitNested func(c *NestedContext)

+ ExitNull func(c *NullContext)

+ ExitPrimaryExpr func(c *PrimaryExprContext)

+ ExitRelation func(c *RelationContext)

+ ExitSelectOrCall func(c *SelectOrCallContext)

+ ExitStart func(c *StartContext)

+ ExitString func(c *StringContext)

+ ExitUint func(c *UintContext)

+ type CELParser struct

+ func NewCELParser(input antlr.TokenStream) *CELParser

+ func (p *CELParser) Calc() (localctx ICalcContext)

+ func (p *CELParser) Calc_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CELParser) ConditionalAnd() (localctx IConditionalAndContext)

+ func (p *CELParser) ConditionalOr() (localctx IConditionalOrContext)

+ func (p *CELParser) Expr() (localctx IExprContext)

+ func (p *CELParser) ExprList() (localctx IExprListContext)

+ func (p *CELParser) FieldInitializerList() (localctx IFieldInitializerListContext)

+ func (p *CELParser) Literal() (localctx ILiteralContext)

+ func (p *CELParser) MapInitializerList() (localctx IMapInitializerListContext)

+ func (p *CELParser) Member() (localctx IMemberContext)

+ func (p *CELParser) Member_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CELParser) Primary() (localctx IPrimaryContext)

+ func (p *CELParser) Relation() (localctx IRelationContext)

+ func (p *CELParser) Relation_Sempred(localctx antlr.RuleContext, predIndex int) bool

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

+ func (p *CELParser) Start() (localctx IStartContext)

+ func (p *CELParser) Unary() (localctx IUnaryContext)

+ type CELVisitor interface

+ VisitBoolFalse func(ctx *BoolFalseContext) interface{}

+ VisitBoolTrue func(ctx *BoolTrueContext) interface{}

+ VisitBytes func(ctx *BytesContext) interface{}

+ VisitCalc func(ctx *CalcContext) interface{}

+ VisitConditionalAnd func(ctx *ConditionalAndContext) interface{}

+ VisitConditionalOr func(ctx *ConditionalOrContext) interface{}

+ VisitConstantLiteral func(ctx *ConstantLiteralContext) interface{}

+ VisitCreateList func(ctx *CreateListContext) interface{}

+ VisitCreateMessage func(ctx *CreateMessageContext) interface{}

+ VisitCreateStruct func(ctx *CreateStructContext) interface{}

+ VisitDouble func(ctx *DoubleContext) interface{}

+ VisitExpr func(ctx *ExprContext) interface{}

+ VisitExprList func(ctx *ExprListContext) interface{}

+ VisitFieldInitializerList func(ctx *FieldInitializerListContext) interface{}

+ VisitIdentOrGlobalCall func(ctx *IdentOrGlobalCallContext) interface{}

+ VisitIndex func(ctx *IndexContext) interface{}

+ VisitInt func(ctx *IntContext) interface{}

+ VisitLogicalNot func(ctx *LogicalNotContext) interface{}

+ VisitMapInitializerList func(ctx *MapInitializerListContext) interface{}

+ VisitMemberExpr func(ctx *MemberExprContext) interface{}

+ VisitNegate func(ctx *NegateContext) interface{}

+ VisitNested func(ctx *NestedContext) interface{}

+ VisitNull func(ctx *NullContext) interface{}

+ VisitPrimaryExpr func(ctx *PrimaryExprContext) interface{}

+ VisitRelation func(ctx *RelationContext) interface{}

+ VisitSelectOrCall func(ctx *SelectOrCallContext) interface{}

+ VisitStart func(ctx *StartContext) interface{}

+ VisitString func(ctx *StringContext) interface{}

+ VisitUint func(ctx *UintContext) interface{}

+ type CalcContext struct

+ func NewCalcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CalcContext

+ func NewEmptyCalcContext() *CalcContext

+ func (*CalcContext) IsCalcContext()

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

+ func (s *CalcContext) AllCalc() []ICalcContext

+ func (s *CalcContext) Calc(i int) ICalcContext

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

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

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

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

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

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

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

+ func (s *CalcContext) Unary() IUnaryContext

+ type ConditionalAndContext struct

+ func NewConditionalAndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalAndContext

+ func NewEmptyConditionalAndContext() *ConditionalAndContext

+ func (*ConditionalAndContext) IsConditionalAndContext()

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

+ func (s *ConditionalAndContext) AllRelation() []IRelationContext

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

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

+ func (s *ConditionalAndContext) GetE() IRelationContext

+ func (s *ConditionalAndContext) GetE1() []IRelationContext

+ func (s *ConditionalAndContext) GetOps() []antlr.Token

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

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

+ func (s *ConditionalAndContext) GetS8() antlr.Token

+ func (s *ConditionalAndContext) Get_relation() IRelationContext

+ func (s *ConditionalAndContext) Relation(i int) IRelationContext

+ func (s *ConditionalAndContext) SetE(v IRelationContext)

+ func (s *ConditionalAndContext) SetE1(v []IRelationContext)

+ func (s *ConditionalAndContext) SetOps(v []antlr.Token)

+ func (s *ConditionalAndContext) SetS8(v antlr.Token)

+ func (s *ConditionalAndContext) Set_relation(v IRelationContext)

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

+ type ConditionalOrContext struct

+ func NewConditionalOrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalOrContext

+ func NewEmptyConditionalOrContext() *ConditionalOrContext

+ func (*ConditionalOrContext) IsConditionalOrContext()

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

+ func (s *ConditionalOrContext) AllConditionalAnd() []IConditionalAndContext

+ func (s *ConditionalOrContext) ConditionalAnd(i int) IConditionalAndContext

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

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

+ func (s *ConditionalOrContext) GetE() IConditionalAndContext

+ func (s *ConditionalOrContext) GetE1() []IConditionalAndContext

+ func (s *ConditionalOrContext) GetOps() []antlr.Token

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

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

+ func (s *ConditionalOrContext) GetS9() antlr.Token

+ func (s *ConditionalOrContext) Get_conditionalAnd() IConditionalAndContext

+ func (s *ConditionalOrContext) SetE(v IConditionalAndContext)

+ func (s *ConditionalOrContext) SetE1(v []IConditionalAndContext)

+ func (s *ConditionalOrContext) SetOps(v []antlr.Token)

+ func (s *ConditionalOrContext) SetS9(v antlr.Token)

+ func (s *ConditionalOrContext) Set_conditionalAnd(v IConditionalAndContext)

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

+ type ConstantLiteralContext struct

+ func NewConstantLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantLiteralContext

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

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

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

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

+ func (s *ConstantLiteralContext) Literal() ILiteralContext

+ type CreateListContext struct

+ func NewCreateListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateListContext

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

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

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

+ func (s *CreateListContext) ExprList() IExprListContext

+ func (s *CreateListContext) GetElems() IExprListContext

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

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

+ func (s *CreateListContext) SetElems(v IExprListContext)

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

+ type CreateMessageContext struct

+ func NewCreateMessageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateMessageContext

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

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

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

+ func (s *CreateMessageContext) FieldInitializerList() IFieldInitializerListContext

+ func (s *CreateMessageContext) GetEntries() IFieldInitializerListContext

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

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

+ func (s *CreateMessageContext) Member() IMemberContext

+ func (s *CreateMessageContext) SetEntries(v IFieldInitializerListContext)

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

+ type CreateStructContext struct

+ func NewCreateStructContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateStructContext

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

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

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

+ func (s *CreateStructContext) GetEntries() IMapInitializerListContext

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

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

+ func (s *CreateStructContext) MapInitializerList() IMapInitializerListContext

+ func (s *CreateStructContext) SetEntries(v IMapInitializerListContext)

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

+ type DoubleContext struct

+ func NewDoubleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoubleContext

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

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

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

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

+ func (s *DoubleContext) GetSign() antlr.Token

+ func (s *DoubleContext) GetTok() antlr.Token

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

+ func (s *DoubleContext) NUM_FLOAT() antlr.TerminalNode

+ func (s *DoubleContext) SetSign(v antlr.Token)

+ func (s *DoubleContext) SetTok(v antlr.Token)

+ type ExprContext struct

+ func NewEmptyExprContext() *ExprContext

+ func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

+ func (*ExprContext) IsExprContext()

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

+ func (s *ExprContext) AllConditionalOr() []IConditionalOrContext

+ func (s *ExprContext) ConditionalOr(i int) IConditionalOrContext

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

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

+ func (s *ExprContext) Expr() IExprContext

+ func (s *ExprContext) GetE() IConditionalOrContext

+ func (s *ExprContext) GetE1() IConditionalOrContext

+ func (s *ExprContext) GetE2() IExprContext

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

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

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

+ func (s *ExprContext) SetE(v IConditionalOrContext)

+ func (s *ExprContext) SetE1(v IConditionalOrContext)

+ func (s *ExprContext) SetE2(v IExprContext)

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

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

+ type ExprListContext struct

+ func NewEmptyExprListContext() *ExprListContext

+ func NewExprListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprListContext

+ func (*ExprListContext) IsExprListContext()

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

+ func (s *ExprListContext) AllExpr() []IExprContext

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

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

+ func (s *ExprListContext) Expr(i int) IExprContext

+ func (s *ExprListContext) GetE() []IExprContext

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

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

+ func (s *ExprListContext) Get_expr() IExprContext

+ func (s *ExprListContext) SetE(v []IExprContext)

+ func (s *ExprListContext) Set_expr(v IExprContext)

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

+ type FieldInitializerListContext struct

+ func NewEmptyFieldInitializerListContext() *FieldInitializerListContext

+ func NewFieldInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldInitializerListContext

+ func (*FieldInitializerListContext) IsFieldInitializerListContext()

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

+ func (s *FieldInitializerListContext) AllExpr() []IExprContext

+ func (s *FieldInitializerListContext) AllIDENTIFIER() []antlr.TerminalNode

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

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

+ func (s *FieldInitializerListContext) Expr(i int) IExprContext

+ func (s *FieldInitializerListContext) GetCols() []antlr.Token

+ func (s *FieldInitializerListContext) GetFields() []antlr.Token

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

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

+ func (s *FieldInitializerListContext) GetS21() antlr.Token

+ func (s *FieldInitializerListContext) GetValues() []IExprContext

+ func (s *FieldInitializerListContext) Get_IDENTIFIER() antlr.Token

+ func (s *FieldInitializerListContext) Get_expr() IExprContext

+ func (s *FieldInitializerListContext) IDENTIFIER(i int) antlr.TerminalNode

+ func (s *FieldInitializerListContext) SetCols(v []antlr.Token)

+ func (s *FieldInitializerListContext) SetFields(v []antlr.Token)

+ func (s *FieldInitializerListContext) SetS21(v antlr.Token)

+ func (s *FieldInitializerListContext) SetValues(v []IExprContext)

+ func (s *FieldInitializerListContext) Set_IDENTIFIER(v antlr.Token)

+ func (s *FieldInitializerListContext) Set_expr(v IExprContext)

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

+ type ICalcContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsCalcContext func()

+ SetOp func(antlr.Token)

+ type IConditionalAndContext interface

+ GetE func() IRelationContext

+ GetE1 func() []IRelationContext

+ GetOps func() []antlr.Token

+ GetParser func() antlr.Parser

+ GetS8 func() antlr.Token

+ Get_relation func() IRelationContext

+ IsConditionalAndContext func()

+ SetE func(IRelationContext)

+ SetE1 func([]IRelationContext)

+ SetOps func([]antlr.Token)

+ SetS8 func(antlr.Token)

+ Set_relation func(IRelationContext)

+ type IConditionalOrContext interface

+ GetE func() IConditionalAndContext

+ GetE1 func() []IConditionalAndContext

+ GetOps func() []antlr.Token

+ GetParser func() antlr.Parser

+ GetS9 func() antlr.Token

+ Get_conditionalAnd func() IConditionalAndContext

+ IsConditionalOrContext func()

+ SetE func(IConditionalAndContext)

+ SetE1 func([]IConditionalAndContext)

+ SetOps func([]antlr.Token)

+ SetS9 func(antlr.Token)

+ Set_conditionalAnd func(IConditionalAndContext)

+ type IExprContext interface

+ GetE func() IConditionalOrContext

+ GetE1 func() IConditionalOrContext

+ GetE2 func() IExprContext

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ SetE func(IConditionalOrContext)

+ SetE1 func(IConditionalOrContext)

+ SetE2 func(IExprContext)

+ SetOp func(antlr.Token)

+ type IExprListContext interface

+ GetE func() []IExprContext

+ GetParser func() antlr.Parser

+ Get_expr func() IExprContext

+ IsExprListContext func()

+ SetE func([]IExprContext)

+ Set_expr func(IExprContext)

+ type IFieldInitializerListContext interface

+ GetCols func() []antlr.Token

+ GetFields func() []antlr.Token

+ GetParser func() antlr.Parser

+ GetS21 func() antlr.Token

+ GetValues func() []IExprContext

+ Get_IDENTIFIER func() antlr.Token

+ Get_expr func() IExprContext

+ IsFieldInitializerListContext func()

+ SetCols func([]antlr.Token)

+ SetFields func([]antlr.Token)

+ SetS21 func(antlr.Token)

+ SetValues func([]IExprContext)

+ Set_IDENTIFIER func(antlr.Token)

+ Set_expr func(IExprContext)

+ type ILiteralContext interface

+ GetParser func() antlr.Parser

+ IsLiteralContext func()

+ type IMapInitializerListContext interface

+ GetCols func() []antlr.Token

+ GetKeys func() []IExprContext

+ GetParser func() antlr.Parser

+ GetS21 func() antlr.Token

+ GetValues func() []IExprContext

+ Get_expr func() IExprContext

+ IsMapInitializerListContext func()

+ SetCols func([]antlr.Token)

+ SetKeys func([]IExprContext)

+ SetS21 func(antlr.Token)

+ SetValues func([]IExprContext)

+ Set_expr func(IExprContext)

+ type IMemberContext interface

+ GetParser func() antlr.Parser

+ IsMemberContext func()

+ type IPrimaryContext interface

+ GetParser func() antlr.Parser

+ IsPrimaryContext func()

+ type IRelationContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsRelationContext func()

+ SetOp func(antlr.Token)

+ type IStartContext interface

+ GetE func() IExprContext

+ GetParser func() antlr.Parser

+ IsStartContext func()

+ SetE func(IExprContext)

+ type IUnaryContext interface

+ GetParser func() antlr.Parser

+ IsUnaryContext func()

+ type IdentOrGlobalCallContext struct

+ func NewIdentOrGlobalCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentOrGlobalCallContext

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

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

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

+ func (s *IdentOrGlobalCallContext) ExprList() IExprListContext

+ func (s *IdentOrGlobalCallContext) GetArgs() IExprListContext

+ func (s *IdentOrGlobalCallContext) GetId() antlr.Token

+ func (s *IdentOrGlobalCallContext) GetLeadingDot() antlr.Token

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

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

+ func (s *IdentOrGlobalCallContext) IDENTIFIER() antlr.TerminalNode

+ func (s *IdentOrGlobalCallContext) SetArgs(v IExprListContext)

+ func (s *IdentOrGlobalCallContext) SetId(v antlr.Token)

+ func (s *IdentOrGlobalCallContext) SetLeadingDot(v antlr.Token)

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

+ type IndexContext struct

+ func NewIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexContext

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

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

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

+ func (s *IndexContext) Expr() IExprContext

+ func (s *IndexContext) GetIndex() IExprContext

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

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

+ func (s *IndexContext) Member() IMemberContext

+ func (s *IndexContext) SetIndex(v IExprContext)

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

+ type IntContext struct

+ func NewIntContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntContext

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

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

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

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

+ func (s *IntContext) GetSign() antlr.Token

+ func (s *IntContext) GetTok() antlr.Token

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

+ func (s *IntContext) NUM_INT() antlr.TerminalNode

+ func (s *IntContext) SetSign(v antlr.Token)

+ func (s *IntContext) SetTok(v antlr.Token)

+ type LiteralContext struct

+ func NewEmptyLiteralContext() *LiteralContext

+ func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext

+ func (*LiteralContext) IsLiteralContext()

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

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

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

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

+ type LogicalNotContext struct

+ func NewLogicalNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalNotContext

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

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

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

+ func (s *LogicalNotContext) GetOps() []antlr.Token

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

+ func (s *LogicalNotContext) GetS19() antlr.Token

+ func (s *LogicalNotContext) Member() IMemberContext

+ func (s *LogicalNotContext) SetOps(v []antlr.Token)

+ func (s *LogicalNotContext) SetS19(v antlr.Token)

+ type MapInitializerListContext struct

+ func NewEmptyMapInitializerListContext() *MapInitializerListContext

+ func NewMapInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapInitializerListContext

+ func (*MapInitializerListContext) IsMapInitializerListContext()

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

+ func (s *MapInitializerListContext) AllExpr() []IExprContext

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

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

+ func (s *MapInitializerListContext) Expr(i int) IExprContext

+ func (s *MapInitializerListContext) GetCols() []antlr.Token

+ func (s *MapInitializerListContext) GetKeys() []IExprContext

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

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

+ func (s *MapInitializerListContext) GetS21() antlr.Token

+ func (s *MapInitializerListContext) GetValues() []IExprContext

+ func (s *MapInitializerListContext) Get_expr() IExprContext

+ func (s *MapInitializerListContext) SetCols(v []antlr.Token)

+ func (s *MapInitializerListContext) SetKeys(v []IExprContext)

+ func (s *MapInitializerListContext) SetS21(v antlr.Token)

+ func (s *MapInitializerListContext) SetValues(v []IExprContext)

+ func (s *MapInitializerListContext) Set_expr(v IExprContext)

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

+ type MemberContext struct

+ func NewEmptyMemberContext() *MemberContext

+ func NewMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberContext

+ func (*MemberContext) IsMemberContext()

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

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

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

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

+ type MemberExprContext struct

+ func NewMemberExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberExprContext

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

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

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

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

+ func (s *MemberExprContext) Member() IMemberContext

+ type NegateContext struct

+ func NewNegateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NegateContext

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

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

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

+ func (s *NegateContext) GetOps() []antlr.Token

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

+ func (s *NegateContext) GetS18() antlr.Token

+ func (s *NegateContext) Member() IMemberContext

+ func (s *NegateContext) SetOps(v []antlr.Token)

+ func (s *NegateContext) SetS18(v antlr.Token)

+ type NestedContext struct

+ func NewNestedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedContext

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

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

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

+ func (s *NestedContext) Expr() IExprContext

+ func (s *NestedContext) GetE() IExprContext

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

+ func (s *NestedContext) SetE(v IExprContext)

+ type NullContext struct

+ func NewNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullContext

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

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

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

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

+ func (s *NullContext) GetTok() antlr.Token

+ func (s *NullContext) SetTok(v antlr.Token)

+ type PrimaryContext struct

+ func NewEmptyPrimaryContext() *PrimaryContext

+ func NewPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryContext

+ func (*PrimaryContext) IsPrimaryContext()

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

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

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

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

+ type PrimaryExprContext struct

+ func NewPrimaryExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryExprContext

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

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

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

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

+ func (s *PrimaryExprContext) Primary() IPrimaryContext

+ type RelationContext struct

+ func NewEmptyRelationContext() *RelationContext

+ func NewRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationContext

+ func (*RelationContext) IsRelationContext()

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

+ func (s *RelationContext) AllRelation() []IRelationContext

+ func (s *RelationContext) Calc() ICalcContext

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

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

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

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

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

+ func (s *RelationContext) Relation(i int) IRelationContext

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

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

+ type SelectOrCallContext struct

+ func NewSelectOrCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectOrCallContext

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

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

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

+ func (s *SelectOrCallContext) ExprList() IExprListContext

+ func (s *SelectOrCallContext) GetArgs() IExprListContext

+ func (s *SelectOrCallContext) GetId() antlr.Token

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

+ func (s *SelectOrCallContext) GetOpen() antlr.Token

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

+ func (s *SelectOrCallContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SelectOrCallContext) Member() IMemberContext

+ func (s *SelectOrCallContext) SetArgs(v IExprListContext)

+ func (s *SelectOrCallContext) SetId(v antlr.Token)

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

+ func (s *SelectOrCallContext) SetOpen(v antlr.Token)

+ type StartContext struct

+ func NewEmptyStartContext() *StartContext

+ func NewStartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartContext

+ func (*StartContext) IsStartContext()

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

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

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

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

+ func (s *StartContext) Expr() IExprContext

+ func (s *StartContext) GetE() IExprContext

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

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

+ func (s *StartContext) SetE(v IExprContext)

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

+ type StringContext struct

+ func NewStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringContext

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

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

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

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

+ func (s *StringContext) GetTok() antlr.Token

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

+ func (s *StringContext) SetTok(v antlr.Token)

+ type UintContext struct

+ func NewUintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UintContext

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

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

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

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

+ func (s *UintContext) GetTok() antlr.Token

+ func (s *UintContext) NUM_UINT() antlr.TerminalNode

+ func (s *UintContext) SetTok(v antlr.Token)

+ type UnaryContext struct

+ func NewEmptyUnaryContext() *UnaryContext

+ func NewUnaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryContext

+ func (*UnaryContext) IsUnaryContext()

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

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

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

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

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