parser

package

Go to main page

Versions in this module

v1

v1.6.7

Sep 4, 2024

v1.6.6

Apr 7, 2024

Changes in this version

type ILogicalOperatorContext

+ SIN func() antlr.TerminalNode

+ SINC func() antlr.TerminalNode

+ SNIN func() antlr.TerminalNode

+ SNINC func() antlr.TerminalNode

type LogicalOperatorContext

+ func (s *LogicalOperatorContext) SIN() antlr.TerminalNode

+ func (s *LogicalOperatorContext) SINC() antlr.TerminalNode

+ func (s *LogicalOperatorContext) SNIN() antlr.TerminalNode

+ func (s *LogicalOperatorContext) SNINC() antlr.TerminalNode

v1.6.5

Dec 17, 2023

v1.6.4-d2

Dec 16, 2023

v1.6.4-d1

Dec 12, 2023

v1.6.4-d

Nov 15, 2023

v1.6.3-d

Nov 15, 2023

v1.6.2

Sep 12, 2023

v1.6.1

Sep 10, 2023

v1.6.0

Sep 10, 2023

Changes in this version

+ var GengineLexerLexerStaticData struct

+ var GengineParserStaticData struct

+ func GengineLexerInit()

+ func GengineParserInit()

+ func InitEmptyAssignOperatorContext(p *AssignOperatorContext)

+ func InitEmptyAssignmentContext(p *AssignmentContext)

+ func InitEmptyAtCodeContext(p *AtCodeContext)

+ func InitEmptyAtDescContext(p *AtDescContext)

+ func InitEmptyAtIdContext(p *AtIdContext)

+ func InitEmptyAtNameContext(p *AtNameContext)

+ func InitEmptyAtSalContext(p *AtSalContext)

+ func InitEmptyBooleanLiteralContext(p *BooleanLiteralContext)

+ func InitEmptyBreakStmtContext(p *BreakStmtContext)

+ func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext)

+ func InitEmptyConcStatementContext(p *ConcStatementContext)

+ func InitEmptyConstantContext(p *ConstantContext)

+ func InitEmptyContinueStmtContext(p *ContinueStmtContext)

+ func InitEmptyElseIfStmtContext(p *ElseIfStmtContext)

+ func InitEmptyElseStmtContext(p *ElseStmtContext)

+ func InitEmptyExpressionAtomContext(p *ExpressionAtomContext)

+ func InitEmptyExpressionContext(p *ExpressionContext)

+ func InitEmptyForRangeStmtContext(p *ForRangeStmtContext)

+ func InitEmptyForStmtContext(p *ForStmtContext)

+ func InitEmptyFunctionArgsContext(p *FunctionArgsContext)

+ func InitEmptyFunctionCallContext(p *FunctionCallContext)

+ func InitEmptyIfStmtContext(p *IfStmtContext)

+ func InitEmptyIntegerContext(p *IntegerContext)

+ func InitEmptyLogicalOperatorContext(p *LogicalOperatorContext)

+ func InitEmptyMapVarContext(p *MapVarContext)

+ func InitEmptyMathExpressionContext(p *MathExpressionContext)

+ func InitEmptyMathMdOperatorContext(p *MathMdOperatorContext)

+ func InitEmptyMathPmOperatorContext(p *MathPmOperatorContext)

+ func InitEmptyMethodCallContext(p *MethodCallContext)

+ func InitEmptyNotOperatorContext(p *NotOperatorContext)

+ func InitEmptyPrimaryContext(p *PrimaryContext)

+ func InitEmptyRangeOperatorContext(p *RangeOperatorContext)

+ func InitEmptyRealLiteralContext(p *RealLiteralContext)

+ func InitEmptyReturnStmtContext(p *ReturnStmtContext)

+ func InitEmptyRuleContentContext(p *RuleContentContext)

+ func InitEmptyRuleDescriptionContext(p *RuleDescriptionContext)

+ func InitEmptyRuleEntityContext(p *RuleEntityContext)

+ func InitEmptyRuleNameContext(p *RuleNameContext)

+ func InitEmptySalienceContext(p *SalienceContext)

+ func InitEmptyStatementContext(p *StatementContext)

+ func InitEmptyStatementsContext(p *StatementsContext)

+ func InitEmptyStringLiteralContext(p *StringLiteralContext)

+ func InitEmptyThreeLevelCallContext(p *ThreeLevelCallContext)

+ func InitEmptyVariableContext(p *VariableContext)

+ func NewgengineLexer(input antlr.CharStream) *gengineLexer

+ func NewgengineParser(input antlr.TokenStream) *gengineParser

+ type AssignOperatorContext struct

+ func NewAssignOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignOperatorContext

+ func NewEmptyAssignOperatorContext() *AssignOperatorContext

+ func (*AssignOperatorContext) IsAssignOperatorContext()

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

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

+ func (s *AssignOperatorContext) DIVEQUAL() antlr.TerminalNode

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

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

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

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

+ func (s *AssignOperatorContext) MINUSEQUAL() antlr.TerminalNode

+ func (s *AssignOperatorContext) MULTIEQUAL() antlr.TerminalNode

+ func (s *AssignOperatorContext) PLUSEQUAL() antlr.TerminalNode

+ func (s *AssignOperatorContext) SET() antlr.TerminalNode

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

+ type AssignmentContext struct

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

+ func NewEmptyAssignmentContext() *AssignmentContext

+ func (*AssignmentContext) IsAssignmentContext()

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

+ func (s *AssignmentContext) AssignOperator() IAssignOperatorContext

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

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

+ func (s *AssignmentContext) Expression() IExpressionContext

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

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

+ func (s *AssignmentContext) MapVar() IMapVarContext

+ func (s *AssignmentContext) MathExpression() IMathExpressionContext

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

+ func (s *AssignmentContext) Variable() IVariableContext

+ type AtCodeContext struct

+ func NewAtCodeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtCodeContext

+ func NewEmptyAtCodeContext() *AtCodeContext

+ func (*AtCodeContext) IsAtCodeContext()

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

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

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

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

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

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

+ type AtDescContext struct

+ func NewAtDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtDescContext

+ func NewEmptyAtDescContext() *AtDescContext

+ func (*AtDescContext) IsAtDescContext()

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

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

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

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

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

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

+ type AtIdContext struct

+ func NewAtIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtIdContext

+ func NewEmptyAtIdContext() *AtIdContext

+ func (*AtIdContext) IsAtIdContext()

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

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

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

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

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

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

+ type AtNameContext struct

+ func NewAtNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtNameContext

+ func NewEmptyAtNameContext() *AtNameContext

+ func (*AtNameContext) IsAtNameContext()

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

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

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

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

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

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

+ type AtSalContext struct

+ func NewAtSalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtSalContext

+ func NewEmptyAtSalContext() *AtSalContext

+ func (*AtSalContext) IsAtSalContext()

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

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

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

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

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

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

+ type BasegengineListener struct

+ func (s *BasegengineListener) EnterAssignOperator(ctx *AssignOperatorContext)

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

+ func (s *BasegengineListener) EnterAtCode(ctx *AtCodeContext)

+ func (s *BasegengineListener) EnterAtDesc(ctx *AtDescContext)

+ func (s *BasegengineListener) EnterAtId(ctx *AtIdContext)

+ func (s *BasegengineListener) EnterAtName(ctx *AtNameContext)

+ func (s *BasegengineListener) EnterAtSal(ctx *AtSalContext)

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

+ func (s *BasegengineListener) EnterBreakStmt(ctx *BreakStmtContext)

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

+ func (s *BasegengineListener) EnterConcStatement(ctx *ConcStatementContext)

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

+ func (s *BasegengineListener) EnterContinueStmt(ctx *ContinueStmtContext)

+ func (s *BasegengineListener) EnterElseIfStmt(ctx *ElseIfStmtContext)

+ func (s *BasegengineListener) EnterElseStmt(ctx *ElseStmtContext)

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

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

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

+ func (s *BasegengineListener) EnterForRangeStmt(ctx *ForRangeStmtContext)

+ func (s *BasegengineListener) EnterForStmt(ctx *ForStmtContext)

+ func (s *BasegengineListener) EnterFunctionArgs(ctx *FunctionArgsContext)

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

+ func (s *BasegengineListener) EnterIfStmt(ctx *IfStmtContext)

+ func (s *BasegengineListener) EnterInteger(ctx *IntegerContext)

+ func (s *BasegengineListener) EnterLogicalOperator(ctx *LogicalOperatorContext)

+ func (s *BasegengineListener) EnterMapVar(ctx *MapVarContext)

+ func (s *BasegengineListener) EnterMathExpression(ctx *MathExpressionContext)

+ func (s *BasegengineListener) EnterMathMdOperator(ctx *MathMdOperatorContext)

+ func (s *BasegengineListener) EnterMathPmOperator(ctx *MathPmOperatorContext)

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

+ func (s *BasegengineListener) EnterNotOperator(ctx *NotOperatorContext)

+ func (s *BasegengineListener) EnterPrimary(ctx *PrimaryContext)

+ func (s *BasegengineListener) EnterRangeOperator(ctx *RangeOperatorContext)

+ func (s *BasegengineListener) EnterRealLiteral(ctx *RealLiteralContext)

+ func (s *BasegengineListener) EnterReturnStmt(ctx *ReturnStmtContext)

+ func (s *BasegengineListener) EnterRuleContent(ctx *RuleContentContext)

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

+ func (s *BasegengineListener) EnterRuleEntity(ctx *RuleEntityContext)

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

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

+ func (s *BasegengineListener) EnterStatement(ctx *StatementContext)

+ func (s *BasegengineListener) EnterStatements(ctx *StatementsContext)

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

+ func (s *BasegengineListener) EnterThreeLevelCall(ctx *ThreeLevelCallContext)

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

+ func (s *BasegengineListener) ExitAssignOperator(ctx *AssignOperatorContext)

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

+ func (s *BasegengineListener) ExitAtCode(ctx *AtCodeContext)

+ func (s *BasegengineListener) ExitAtDesc(ctx *AtDescContext)

+ func (s *BasegengineListener) ExitAtId(ctx *AtIdContext)

+ func (s *BasegengineListener) ExitAtName(ctx *AtNameContext)

+ func (s *BasegengineListener) ExitAtSal(ctx *AtSalContext)

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

+ func (s *BasegengineListener) ExitBreakStmt(ctx *BreakStmtContext)

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

+ func (s *BasegengineListener) ExitConcStatement(ctx *ConcStatementContext)

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

+ func (s *BasegengineListener) ExitContinueStmt(ctx *ContinueStmtContext)

+ func (s *BasegengineListener) ExitElseIfStmt(ctx *ElseIfStmtContext)

+ func (s *BasegengineListener) ExitElseStmt(ctx *ElseStmtContext)

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

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

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

+ func (s *BasegengineListener) ExitForRangeStmt(ctx *ForRangeStmtContext)

+ func (s *BasegengineListener) ExitForStmt(ctx *ForStmtContext)

+ func (s *BasegengineListener) ExitFunctionArgs(ctx *FunctionArgsContext)

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

+ func (s *BasegengineListener) ExitIfStmt(ctx *IfStmtContext)

+ func (s *BasegengineListener) ExitInteger(ctx *IntegerContext)

+ func (s *BasegengineListener) ExitLogicalOperator(ctx *LogicalOperatorContext)

+ func (s *BasegengineListener) ExitMapVar(ctx *MapVarContext)

+ func (s *BasegengineListener) ExitMathExpression(ctx *MathExpressionContext)

+ func (s *BasegengineListener) ExitMathMdOperator(ctx *MathMdOperatorContext)

+ func (s *BasegengineListener) ExitMathPmOperator(ctx *MathPmOperatorContext)

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

+ func (s *BasegengineListener) ExitNotOperator(ctx *NotOperatorContext)

+ func (s *BasegengineListener) ExitPrimary(ctx *PrimaryContext)

+ func (s *BasegengineListener) ExitRangeOperator(ctx *RangeOperatorContext)

+ func (s *BasegengineListener) ExitRealLiteral(ctx *RealLiteralContext)

+ func (s *BasegengineListener) ExitReturnStmt(ctx *ReturnStmtContext)

+ func (s *BasegengineListener) ExitRuleContent(ctx *RuleContentContext)

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

+ func (s *BasegengineListener) ExitRuleEntity(ctx *RuleEntityContext)

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

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

+ func (s *BasegengineListener) ExitStatement(ctx *StatementContext)

+ func (s *BasegengineListener) ExitStatements(ctx *StatementsContext)

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

+ func (s *BasegengineListener) ExitThreeLevelCall(ctx *ThreeLevelCallContext)

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

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

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

+ type BasegengineVisitor struct

+ func (v *BasegengineVisitor) VisitAssignOperator(ctx *AssignOperatorContext) interface{}

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

+ func (v *BasegengineVisitor) VisitAtCode(ctx *AtCodeContext) interface{}

+ func (v *BasegengineVisitor) VisitAtDesc(ctx *AtDescContext) interface{}

+ func (v *BasegengineVisitor) VisitAtId(ctx *AtIdContext) interface{}

+ func (v *BasegengineVisitor) VisitAtName(ctx *AtNameContext) interface{}

+ func (v *BasegengineVisitor) VisitAtSal(ctx *AtSalContext) interface{}

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

+ func (v *BasegengineVisitor) VisitBreakStmt(ctx *BreakStmtContext) interface{}

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

+ func (v *BasegengineVisitor) VisitConcStatement(ctx *ConcStatementContext) interface{}

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

+ func (v *BasegengineVisitor) VisitContinueStmt(ctx *ContinueStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitElseIfStmt(ctx *ElseIfStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitElseStmt(ctx *ElseStmtContext) interface{}

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

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

+ func (v *BasegengineVisitor) VisitForRangeStmt(ctx *ForRangeStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitForStmt(ctx *ForStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitFunctionArgs(ctx *FunctionArgsContext) interface{}

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

+ func (v *BasegengineVisitor) VisitIfStmt(ctx *IfStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitInteger(ctx *IntegerContext) interface{}

+ func (v *BasegengineVisitor) VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

+ func (v *BasegengineVisitor) VisitMapVar(ctx *MapVarContext) interface{}

+ func (v *BasegengineVisitor) VisitMathExpression(ctx *MathExpressionContext) interface{}

+ func (v *BasegengineVisitor) VisitMathMdOperator(ctx *MathMdOperatorContext) interface{}

+ func (v *BasegengineVisitor) VisitMathPmOperator(ctx *MathPmOperatorContext) interface{}

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

+ func (v *BasegengineVisitor) VisitNotOperator(ctx *NotOperatorContext) interface{}

+ func (v *BasegengineVisitor) VisitPrimary(ctx *PrimaryContext) interface{}

+ func (v *BasegengineVisitor) VisitRangeOperator(ctx *RangeOperatorContext) interface{}

+ func (v *BasegengineVisitor) VisitRealLiteral(ctx *RealLiteralContext) interface{}

+ func (v *BasegengineVisitor) VisitReturnStmt(ctx *ReturnStmtContext) interface{}

+ func (v *BasegengineVisitor) VisitRuleContent(ctx *RuleContentContext) interface{}

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

+ func (v *BasegengineVisitor) VisitRuleEntity(ctx *RuleEntityContext) interface{}

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

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

+ func (v *BasegengineVisitor) VisitStatement(ctx *StatementContext) interface{}

+ func (v *BasegengineVisitor) VisitStatements(ctx *StatementsContext) interface{}

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

+ func (v *BasegengineVisitor) VisitThreeLevelCall(ctx *ThreeLevelCallContext) interface{}

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

+ type BooleanLiteralContext struct

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

+ func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

+ func (*BooleanLiteralContext) IsBooleanLiteralContext()

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

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

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

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

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

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

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

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

+ type BreakStmtContext struct

+ func NewBreakStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStmtContext

+ func NewEmptyBreakStmtContext() *BreakStmtContext

+ func (*BreakStmtContext) IsBreakStmtContext()

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

+ func (s *BreakStmtContext) BREAK() antlr.TerminalNode

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

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

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

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

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

+ type ComparisonOperatorContext struct

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

+ func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext

+ func (*ComparisonOperatorContext) IsComparisonOperatorContext()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type ConcStatementContext struct

+ func NewConcStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConcStatementContext

+ func NewEmptyConcStatementContext() *ConcStatementContext

+ func (*ConcStatementContext) IsConcStatementContext()

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

+ func (s *ConcStatementContext) AllAssignment() []IAssignmentContext

+ func (s *ConcStatementContext) AllFunctionCall() []IFunctionCallContext

+ func (s *ConcStatementContext) AllMethodCall() []IMethodCallContext

+ func (s *ConcStatementContext) AllThreeLevelCall() []IThreeLevelCallContext

+ func (s *ConcStatementContext) Assignment(i int) IAssignmentContext

+ func (s *ConcStatementContext) CONC() antlr.TerminalNode

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

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

+ func (s *ConcStatementContext) FunctionCall(i int) IFunctionCallContext

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

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

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

+ func (s *ConcStatementContext) MethodCall(i int) IMethodCallContext

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

+ func (s *ConcStatementContext) ThreeLevelCall(i int) IThreeLevelCallContext

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

+ type ConstantContext struct

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

+ func NewEmptyConstantContext() *ConstantContext

+ func (*ConstantContext) IsConstantContext()

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

+ func (s *ConstantContext) AtCode() IAtCodeContext

+ func (s *ConstantContext) AtDesc() IAtDescContext

+ func (s *ConstantContext) AtId() IAtIdContext

+ func (s *ConstantContext) AtName() IAtNameContext

+ func (s *ConstantContext) AtSal() IAtSalContext

+ func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext

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

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

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

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

+ func (s *ConstantContext) Integer() IIntegerContext

+ func (s *ConstantContext) RealLiteral() IRealLiteralContext

+ func (s *ConstantContext) StringLiteral() IStringLiteralContext

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

+ type ContinueStmtContext struct

+ func NewContinueStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStmtContext

+ func NewEmptyContinueStmtContext() *ContinueStmtContext

+ func (*ContinueStmtContext) IsContinueStmtContext()

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

+ func (s *ContinueStmtContext) CONTINUE() antlr.TerminalNode

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

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

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

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

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

+ type ElseIfStmtContext struct

+ func NewElseIfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElseIfStmtContext

+ func NewEmptyElseIfStmtContext() *ElseIfStmtContext

+ func (*ElseIfStmtContext) IsElseIfStmtContext()

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

+ func (s *ElseIfStmtContext) ELSE() antlr.TerminalNode

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

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

+ func (s *ElseIfStmtContext) Expression() IExpressionContext

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

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

+ func (s *ElseIfStmtContext) IF() antlr.TerminalNode

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

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

+ func (s *ElseIfStmtContext) Statements() IStatementsContext

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

+ type ElseStmtContext struct

+ func NewElseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElseStmtContext

+ func NewEmptyElseStmtContext() *ElseStmtContext

+ func (*ElseStmtContext) IsElseStmtContext()

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

+ func (s *ElseStmtContext) ELSE() antlr.TerminalNode

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

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

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

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

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

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

+ func (s *ElseStmtContext) Statements() IStatementsContext

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

+ type ExpressionAtomContext struct

+ func NewEmptyExpressionAtomContext() *ExpressionAtomContext

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

+ func (*ExpressionAtomContext) IsExpressionAtomContext()

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

+ func (s *ExpressionAtomContext) Constant() IConstantContext

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

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

+ func (s *ExpressionAtomContext) FunctionCall() IFunctionCallContext

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

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

+ func (s *ExpressionAtomContext) MapVar() IMapVarContext

+ func (s *ExpressionAtomContext) MethodCall() IMethodCallContext

+ func (s *ExpressionAtomContext) ThreeLevelCall() IThreeLevelCallContext

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

+ func (s *ExpressionAtomContext) Variable() IVariableContext

+ type ExpressionContext struct

+ func NewEmptyExpressionContext() *ExpressionContext

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

+ func (*ExpressionContext) IsExpressionContext()

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

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

+ func (s *ExpressionContext) ComparisonOperator() IComparisonOperatorContext

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

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

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

+ func (s *ExpressionContext) ExpressionAtom() IExpressionAtomContext

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

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

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

+ func (s *ExpressionContext) LogicalOperator() ILogicalOperatorContext

+ func (s *ExpressionContext) MathExpression() IMathExpressionContext

+ func (s *ExpressionContext) NotOperator() INotOperatorContext

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

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

+ type ForRangeStmtContext struct

+ func NewEmptyForRangeStmtContext() *ForRangeStmtContext

+ func NewForRangeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForRangeStmtContext

+ func (*ForRangeStmtContext) IsForRangeStmtContext()

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

+ func (s *ForRangeStmtContext) AllVariable() []IVariableContext

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

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

+ func (s *ForRangeStmtContext) FORRANGE() antlr.TerminalNode

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

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

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

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

+ func (s *ForRangeStmtContext) RangeOperator() IRangeOperatorContext

+ func (s *ForRangeStmtContext) Statements() IStatementsContext

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

+ func (s *ForRangeStmtContext) Variable(i int) IVariableContext

+ type ForStmtContext struct

+ func NewEmptyForStmtContext() *ForStmtContext

+ func NewForStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStmtContext

+ func (*ForStmtContext) IsForStmtContext()

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

+ func (s *ForStmtContext) AllAssignment() []IAssignmentContext

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

+ func (s *ForStmtContext) Assignment(i int) IAssignmentContext

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

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

+ func (s *ForStmtContext) Expression() IExpressionContext

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

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

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

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

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

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

+ func (s *ForStmtContext) Statements() IStatementsContext

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

+ type FunctionArgsContext struct

+ func NewEmptyFunctionArgsContext() *FunctionArgsContext

+ func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext

+ func (*FunctionArgsContext) IsFunctionArgsContext()

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

+ func (s *FunctionArgsContext) AllConstant() []IConstantContext

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

+ func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext

+ func (s *FunctionArgsContext) AllMapVar() []IMapVarContext

+ func (s *FunctionArgsContext) AllMethodCall() []IMethodCallContext

+ func (s *FunctionArgsContext) AllThreeLevelCall() []IThreeLevelCallContext

+ func (s *FunctionArgsContext) AllVariable() []IVariableContext

+ func (s *FunctionArgsContext) Constant(i int) IConstantContext

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

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

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

+ func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext

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

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

+ func (s *FunctionArgsContext) MapVar(i int) IMapVarContext

+ func (s *FunctionArgsContext) MethodCall(i int) IMethodCallContext

+ func (s *FunctionArgsContext) ThreeLevelCall(i int) IThreeLevelCallContext

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

+ func (s *FunctionArgsContext) Variable(i int) IVariableContext

+ type FunctionCallContext struct

+ func NewEmptyFunctionCallContext() *FunctionCallContext

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

+ func (*FunctionCallContext) IsFunctionCallContext()

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

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

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

+ func (s *FunctionCallContext) FunctionArgs() IFunctionArgsContext

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

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

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

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

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

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

+ type IAssignOperatorContext interface

+ ASSIGN func() antlr.TerminalNode

+ DIVEQUAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAssignOperatorContext func()

+ MINUSEQUAL func() antlr.TerminalNode

+ MULTIEQUAL func() antlr.TerminalNode

+ PLUSEQUAL func() antlr.TerminalNode

+ SET func() antlr.TerminalNode

+ type IAssignmentContext interface

+ AssignOperator func() IAssignOperatorContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsAssignmentContext func()

+ MapVar func() IMapVarContext

+ MathExpression func() IMathExpressionContext

+ Variable func() IVariableContext

+ type IAtCodeContext interface

+ GetParser func() antlr.Parser

+ IsAtCodeContext func()

+ type IAtDescContext interface

+ GetParser func() antlr.Parser

+ IsAtDescContext func()

+ type IAtIdContext interface

+ GetParser func() antlr.Parser

+ IsAtIdContext func()

+ type IAtNameContext interface

+ GetParser func() antlr.Parser

+ IsAtNameContext func()

+ type IAtSalContext interface

+ GetParser func() antlr.Parser

+ IsAtSalContext func()

+ type IBooleanLiteralContext interface

+ FALSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsBooleanLiteralContext func()

+ TRUE func() antlr.TerminalNode

+ type IBreakStmtContext interface

+ BREAK func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsBreakStmtContext func()

+ type IComparisonOperatorContext interface

+ EQUALS func() antlr.TerminalNode

+ EQUALS_STR func() antlr.TerminalNode

+ GT func() antlr.TerminalNode

+ GTE func() antlr.TerminalNode

+ GTE_STR func() antlr.TerminalNode

+ GT_STR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsComparisonOperatorContext func()

+ LT func() antlr.TerminalNode

+ LTE func() antlr.TerminalNode

+ LTE_STR func() antlr.TerminalNode

+ LT_STR func() antlr.TerminalNode

+ NOTEQUALS func() antlr.TerminalNode

+ NOTEQUALS_STR func() antlr.TerminalNode

+ type IConcStatementContext interface

+ AllAssignment func() []IAssignmentContext

+ AllFunctionCall func() []IFunctionCallContext

+ AllMethodCall func() []IMethodCallContext

+ AllThreeLevelCall func() []IThreeLevelCallContext

+ Assignment func(i int) IAssignmentContext

+ CONC func() antlr.TerminalNode

+ FunctionCall func(i int) IFunctionCallContext

+ GetParser func() antlr.Parser

+ IsConcStatementContext func()

+ LR_BRACE func() antlr.TerminalNode

+ MethodCall func(i int) IMethodCallContext

+ RR_BRACE func() antlr.TerminalNode

+ ThreeLevelCall func(i int) IThreeLevelCallContext

+ type IConstantContext interface

+ AtCode func() IAtCodeContext

+ AtDesc func() IAtDescContext

+ AtId func() IAtIdContext

+ AtName func() IAtNameContext

+ AtSal func() IAtSalContext

+ BooleanLiteral func() IBooleanLiteralContext

+ GetParser func() antlr.Parser

+ Integer func() IIntegerContext

+ IsConstantContext func()

+ RealLiteral func() IRealLiteralContext

+ StringLiteral func() IStringLiteralContext

+ type IContinueStmtContext interface

+ CONTINUE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsContinueStmtContext func()

+ type IElseIfStmtContext interface

+ ELSE func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IF func() antlr.TerminalNode

+ IsElseIfStmtContext func()

+ LR_BRACE func() antlr.TerminalNode

+ RR_BRACE func() antlr.TerminalNode

+ Statements func() IStatementsContext

+ type IElseStmtContext interface

+ ELSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsElseStmtContext func()

+ LR_BRACE func() antlr.TerminalNode

+ RR_BRACE func() antlr.TerminalNode

+ Statements func() IStatementsContext

+ type IExpressionAtomContext interface

+ Constant func() IConstantContext

+ FunctionCall func() IFunctionCallContext

+ GetParser func() antlr.Parser

+ IsExpressionAtomContext func()

+ MapVar func() IMapVarContext

+ MethodCall func() IMethodCallContext

+ ThreeLevelCall func() IThreeLevelCallContext

+ Variable func() IVariableContext

+ type IExpressionContext interface

+ AllExpression func() []IExpressionContext

+ ComparisonOperator func() IComparisonOperatorContext

+ Expression func(i int) IExpressionContext

+ ExpressionAtom func() IExpressionAtomContext

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ LR_BRACKET func() antlr.TerminalNode

+ LogicalOperator func() ILogicalOperatorContext

+ MathExpression func() IMathExpressionContext

+ NotOperator func() INotOperatorContext

+ RR_BRACKET func() antlr.TerminalNode

+ type IForRangeStmtContext interface

+ AllVariable func() []IVariableContext

+ FORRANGE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsForRangeStmtContext func()

+ LR_BRACE func() antlr.TerminalNode

+ RR_BRACE func() antlr.TerminalNode

+ RangeOperator func() IRangeOperatorContext

+ Statements func() IStatementsContext

+ Variable func(i int) IVariableContext

+ type IForStmtContext interface

+ AllAssignment func() []IAssignmentContext

+ AllSEMICOLON func() []antlr.TerminalNode

+ Assignment func(i int) IAssignmentContext

+ Expression func() IExpressionContext

+ FOR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsForStmtContext func()

+ LR_BRACE func() antlr.TerminalNode

+ RR_BRACE func() antlr.TerminalNode

+ SEMICOLON func(i int) antlr.TerminalNode

+ Statements func() IStatementsContext

+ type IFunctionArgsContext interface

+ AllConstant func() []IConstantContext

+ AllExpression func() []IExpressionContext

+ AllFunctionCall func() []IFunctionCallContext

+ AllMapVar func() []IMapVarContext

+ AllMethodCall func() []IMethodCallContext

+ AllThreeLevelCall func() []IThreeLevelCallContext

+ AllVariable func() []IVariableContext

+ Constant func(i int) IConstantContext

+ Expression func(i int) IExpressionContext

+ FunctionCall func(i int) IFunctionCallContext

+ GetParser func() antlr.Parser

+ IsFunctionArgsContext func()

+ MapVar func(i int) IMapVarContext

+ MethodCall func(i int) IMethodCallContext

+ ThreeLevelCall func(i int) IThreeLevelCallContext

+ Variable func(i int) IVariableContext

+ type IFunctionCallContext interface

+ FunctionArgs func() IFunctionArgsContext

+ GetParser func() antlr.Parser

+ IsFunctionCallContext func()

+ LR_BRACKET func() antlr.TerminalNode

+ RR_BRACKET func() antlr.TerminalNode

+ SIMPLENAME func() antlr.TerminalNode

+ type IIfStmtContext interface

+ AllElseIfStmt func() []IElseIfStmtContext

+ ElseIfStmt func(i int) IElseIfStmtContext

+ ElseStmt func() IElseStmtContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IF func() antlr.TerminalNode

+ IsIfStmtContext func()

+ LR_BRACE func() antlr.TerminalNode

+ RR_BRACE func() antlr.TerminalNode

+ Statements func() IStatementsContext

+ type IIntegerContext interface

+ GetParser func() antlr.Parser

+ INT func() antlr.TerminalNode

+ IsIntegerContext func()

+ MINUS func() antlr.TerminalNode

+ type ILogicalOperatorContext interface

+ AND func() antlr.TerminalNode

+ AND_SINGLE func() antlr.TerminalNode

+ AND_STR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLogicalOperatorContext func()

+ OR func() antlr.TerminalNode

+ OR_SINGLE func() antlr.TerminalNode

+ OR_STR func() antlr.TerminalNode

+ type IMapVarContext interface

+ AllVariable func() []IVariableContext

+ GetParser func() antlr.Parser

+ Integer func() IIntegerContext

+ IsMapVarContext func()

+ LSQARE func() antlr.TerminalNode

+ RSQARE func() antlr.TerminalNode

+ StringLiteral func() IStringLiteralContext

+ Variable func(i int) IVariableContext

+ type IMathExpressionContext interface

+ AllMathExpression func() []IMathExpressionContext

+ ExpressionAtom func() IExpressionAtomContext

+ GetParser func() antlr.Parser

+ IsMathExpressionContext func()

+ LR_BRACKET func() antlr.TerminalNode

+ MathExpression func(i int) IMathExpressionContext

+ MathMdOperator func() IMathMdOperatorContext

+ MathPmOperator func() IMathPmOperatorContext

+ RR_BRACKET func() antlr.TerminalNode

+ type IMathMdOperatorContext interface

+ DIV func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMathMdOperatorContext func()

+ MUL func() antlr.TerminalNode

+ type IMathPmOperatorContext interface

+ GetParser func() antlr.Parser

+ IsMathPmOperatorContext func()

+ MINUS func() antlr.TerminalNode

+ PLUS func() antlr.TerminalNode

+ type IMethodCallContext interface

+ DOTTEDNAME func() antlr.TerminalNode

+ FunctionArgs func() IFunctionArgsContext

+ GetParser func() antlr.Parser

+ IsMethodCallContext func()

+ LR_BRACKET func() antlr.TerminalNode

+ RR_BRACKET func() antlr.TerminalNode

+ type INotOperatorContext interface

+ GetParser func() antlr.Parser

+ IsNotOperatorContext func()

+ NOT func() antlr.TerminalNode

+ type IPrimaryContext interface

+ AllRuleEntity func() []IRuleEntityContext

+ GetParser func() antlr.Parser

+ IsPrimaryContext func()

+ RuleEntity func(i int) IRuleEntityContext

+ type IRangeOperatorContext interface

+ ASSIGN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRangeOperatorContext func()

+ type IRealLiteralContext interface

+ GetParser func() antlr.Parser

+ IsRealLiteralContext func()

+ MINUS func() antlr.TerminalNode

+ REAL_LITERAL func() antlr.TerminalNode

+ type IReturnStmtContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsReturnStmtContext func()

+ RETURN func() antlr.TerminalNode

+ type IRuleContentContext interface

+ GetParser func() antlr.Parser

+ IsRuleContentContext func()

+ Statements func() IStatementsContext

+ type IRuleDescriptionContext interface

+ GetParser func() antlr.Parser

+ IsRuleDescriptionContext func()

+ StringLiteral func() IStringLiteralContext

+ type IRuleEntityContext interface

+ BEGIN func() antlr.TerminalNode

+ END func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRuleEntityContext func()

+ RULE func() antlr.TerminalNode

+ RuleContent func() IRuleContentContext

+ RuleDescription func() IRuleDescriptionContext

+ RuleName func() IRuleNameContext

+ Salience func() ISalienceContext

+ type IRuleNameContext interface

+ GetParser func() antlr.Parser

+ IsRuleNameContext func()

+ StringLiteral func() IStringLiteralContext

+ type ISalienceContext interface

+ GetParser func() antlr.Parser

+ Integer func() IIntegerContext

+ IsSalienceContext func()

+ SALIENCE func() antlr.TerminalNode

+ type IStatementContext interface

+ Assignment func() IAssignmentContext

+ BreakStmt func() IBreakStmtContext

+ ConcStatement func() IConcStatementContext

+ ContinueStmt func() IContinueStmtContext

+ ForRangeStmt func() IForRangeStmtContext

+ ForStmt func() IForStmtContext

+ FunctionCall func() IFunctionCallContext

+ GetParser func() antlr.Parser

+ IfStmt func() IIfStmtContext

+ IsStatementContext func()

+ MethodCall func() IMethodCallContext

+ ThreeLevelCall func() IThreeLevelCallContext

+ type IStatementsContext interface

+ AllStatement func() []IStatementContext

+ GetParser func() antlr.Parser

+ IsStatementsContext func()

+ ReturnStmt func() IReturnStmtContext

+ Statement func(i int) IStatementContext

+ type IStringLiteralContext interface

+ DQUOTA_STRING func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsStringLiteralContext func()

+ type IThreeLevelCallContext interface

+ DOUBLEDOTTEDNAME func() antlr.TerminalNode

+ FunctionArgs func() IFunctionArgsContext

+ GetParser func() antlr.Parser

+ IsThreeLevelCallContext func()

+ LR_BRACKET func() antlr.TerminalNode

+ RR_BRACKET func() antlr.TerminalNode

+ type IVariableContext interface

+ DOTTEDNAME func() antlr.TerminalNode

+ DOUBLEDOTTEDNAME func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsVariableContext func()

+ SIMPLENAME func() antlr.TerminalNode

+ type IfStmtContext struct

+ func NewEmptyIfStmtContext() *IfStmtContext

+ func NewIfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStmtContext

+ func (*IfStmtContext) IsIfStmtContext()

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

+ func (s *IfStmtContext) AllElseIfStmt() []IElseIfStmtContext

+ func (s *IfStmtContext) ElseIfStmt(i int) IElseIfStmtContext

+ func (s *IfStmtContext) ElseStmt() IElseStmtContext

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

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

+ func (s *IfStmtContext) Expression() IExpressionContext

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

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

+ func (s *IfStmtContext) IF() antlr.TerminalNode

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

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

+ func (s *IfStmtContext) Statements() IStatementsContext

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

+ type IntegerContext struct

+ func NewEmptyIntegerContext() *IntegerContext

+ func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerContext

+ func (*IntegerContext) IsIntegerContext()

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

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

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

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

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

+ func (s *IntegerContext) INT() antlr.TerminalNode

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

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

+ type LogicalOperatorContext struct

+ func NewEmptyLogicalOperatorContext() *LogicalOperatorContext

+ func NewLogicalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOperatorContext

+ func (*LogicalOperatorContext) IsLogicalOperatorContext()

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

+ func (s *LogicalOperatorContext) AND_SINGLE() antlr.TerminalNode

+ func (s *LogicalOperatorContext) AND_STR() antlr.TerminalNode

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

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

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

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

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

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

+ func (s *LogicalOperatorContext) OR_SINGLE() antlr.TerminalNode

+ func (s *LogicalOperatorContext) OR_STR() antlr.TerminalNode

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

+ type MapVarContext struct

+ func NewEmptyMapVarContext() *MapVarContext

+ func NewMapVarContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapVarContext

+ func (*MapVarContext) IsMapVarContext()

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

+ func (s *MapVarContext) AllVariable() []IVariableContext

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

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

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

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

+ func (s *MapVarContext) Integer() IIntegerContext

+ func (s *MapVarContext) LSQARE() antlr.TerminalNode

+ func (s *MapVarContext) RSQARE() antlr.TerminalNode

+ func (s *MapVarContext) StringLiteral() IStringLiteralContext

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

+ func (s *MapVarContext) Variable(i int) IVariableContext

+ type MathExpressionContext struct

+ func NewEmptyMathExpressionContext() *MathExpressionContext

+ func NewMathExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathExpressionContext

+ func (*MathExpressionContext) IsMathExpressionContext()

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

+ func (s *MathExpressionContext) AllMathExpression() []IMathExpressionContext

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

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

+ func (s *MathExpressionContext) ExpressionAtom() IExpressionAtomContext

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

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

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

+ func (s *MathExpressionContext) MathExpression(i int) IMathExpressionContext

+ func (s *MathExpressionContext) MathMdOperator() IMathMdOperatorContext

+ func (s *MathExpressionContext) MathPmOperator() IMathPmOperatorContext

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

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

+ type MathMdOperatorContext struct

+ func NewEmptyMathMdOperatorContext() *MathMdOperatorContext

+ func NewMathMdOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathMdOperatorContext

+ func (*MathMdOperatorContext) IsMathMdOperatorContext()

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

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

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

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

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

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

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

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

+ type MathPmOperatorContext struct

+ func NewEmptyMathPmOperatorContext() *MathPmOperatorContext

+ func NewMathPmOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathPmOperatorContext

+ func (*MathPmOperatorContext) IsMathPmOperatorContext()

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

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

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

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

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

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

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

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

+ type MethodCallContext struct

+ func NewEmptyMethodCallContext() *MethodCallContext

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

+ func (*MethodCallContext) IsMethodCallContext()

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

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

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

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

+ func (s *MethodCallContext) FunctionArgs() IFunctionArgsContext

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

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

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

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

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

+ type NotOperatorContext struct

+ func NewEmptyNotOperatorContext() *NotOperatorContext

+ func NewNotOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NotOperatorContext

+ func (*NotOperatorContext) IsNotOperatorContext()

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

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

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

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

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

+ func (s *NotOperatorContext) NOT() antlr.TerminalNode

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

+ type PrimaryContext struct

+ func NewEmptyPrimaryContext() *PrimaryContext

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

+ func (*PrimaryContext) IsPrimaryContext()

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

+ func (s *PrimaryContext) AllRuleEntity() []IRuleEntityContext

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

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

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

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

+ func (s *PrimaryContext) RuleEntity(i int) IRuleEntityContext

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

+ type RangeOperatorContext struct

+ func NewEmptyRangeOperatorContext() *RangeOperatorContext

+ func NewRangeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeOperatorContext

+ func (*RangeOperatorContext) IsRangeOperatorContext()

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

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

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

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

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

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

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

+ type RealLiteralContext struct

+ func NewEmptyRealLiteralContext() *RealLiteralContext

+ func NewRealLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RealLiteralContext

+ func (*RealLiteralContext) IsRealLiteralContext()

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

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

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

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

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

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

+ func (s *RealLiteralContext) REAL_LITERAL() antlr.TerminalNode

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

+ type ReturnStmtContext struct

+ func NewEmptyReturnStmtContext() *ReturnStmtContext

+ func NewReturnStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStmtContext

+ func (*ReturnStmtContext) IsReturnStmtContext()

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

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

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

+ func (s *ReturnStmtContext) Expression() IExpressionContext

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

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

+ func (s *ReturnStmtContext) RETURN() antlr.TerminalNode

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

+ type RuleContentContext struct

+ func NewEmptyRuleContentContext() *RuleContentContext

+ func NewRuleContentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleContentContext

+ func (*RuleContentContext) IsRuleContentContext()

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

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

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

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

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

+ func (s *RuleContentContext) Statements() IStatementsContext

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

+ type RuleDescriptionContext struct

+ func NewEmptyRuleDescriptionContext() *RuleDescriptionContext

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

+ func (*RuleDescriptionContext) IsRuleDescriptionContext()

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

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

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

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

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

+ func (s *RuleDescriptionContext) StringLiteral() IStringLiteralContext

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

+ type RuleEntityContext struct

+ func NewEmptyRuleEntityContext() *RuleEntityContext

+ func NewRuleEntityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleEntityContext

+ func (*RuleEntityContext) IsRuleEntityContext()

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

+ func (s *RuleEntityContext) BEGIN() antlr.TerminalNode

+ func (s *RuleEntityContext) END() antlr.TerminalNode

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

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

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

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

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

+ func (s *RuleEntityContext) RuleContent() IRuleContentContext

+ func (s *RuleEntityContext) RuleDescription() IRuleDescriptionContext

+ func (s *RuleEntityContext) RuleName() IRuleNameContext

+ func (s *RuleEntityContext) Salience() ISalienceContext

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

+ type RuleNameContext struct

+ func NewEmptyRuleNameContext() *RuleNameContext

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

+ func (*RuleNameContext) IsRuleNameContext()

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

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

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

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

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

+ func (s *RuleNameContext) StringLiteral() IStringLiteralContext

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

+ type SalienceContext struct

+ func NewEmptySalienceContext() *SalienceContext

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

+ func (*SalienceContext) IsSalienceContext()

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

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

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

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

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

+ func (s *SalienceContext) Integer() IIntegerContext

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

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

+ type StatementContext struct

+ func NewEmptyStatementContext() *StatementContext

+ func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext

+ func (*StatementContext) IsStatementContext()

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

+ func (s *StatementContext) Assignment() IAssignmentContext

+ func (s *StatementContext) BreakStmt() IBreakStmtContext

+ func (s *StatementContext) ConcStatement() IConcStatementContext

+ func (s *StatementContext) ContinueStmt() IContinueStmtContext

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

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

+ func (s *StatementContext) ForRangeStmt() IForRangeStmtContext

+ func (s *StatementContext) ForStmt() IForStmtContext

+ func (s *StatementContext) FunctionCall() IFunctionCallContext

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

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

+ func (s *StatementContext) IfStmt() IIfStmtContext

+ func (s *StatementContext) MethodCall() IMethodCallContext

+ func (s *StatementContext) ThreeLevelCall() IThreeLevelCallContext

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

+ type StatementsContext struct

+ func NewEmptyStatementsContext() *StatementsContext

+ func NewStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementsContext

+ func (*StatementsContext) IsStatementsContext()

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

+ func (s *StatementsContext) AllStatement() []IStatementContext

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

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

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

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

+ func (s *StatementsContext) ReturnStmt() IReturnStmtContext

+ func (s *StatementsContext) Statement(i int) IStatementContext

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

+ type StringLiteralContext struct

+ func NewEmptyStringLiteralContext() *StringLiteralContext

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

+ func (*StringLiteralContext) IsStringLiteralContext()

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

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

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

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

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

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

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

+ type ThreeLevelCallContext struct

+ func NewEmptyThreeLevelCallContext() *ThreeLevelCallContext

+ func NewThreeLevelCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThreeLevelCallContext

+ func (*ThreeLevelCallContext) IsThreeLevelCallContext()

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

+ func (s *ThreeLevelCallContext) DOUBLEDOTTEDNAME() antlr.TerminalNode

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

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

+ func (s *ThreeLevelCallContext) FunctionArgs() IFunctionArgsContext

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

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

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

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

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

+ type VariableContext struct

+ func NewEmptyVariableContext() *VariableContext

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

+ func (*VariableContext) IsVariableContext()

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

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

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

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

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

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

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

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

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

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