parser

Documentation

Index

• Constants
• Variables
• func GetModulePath(c *runtime.Context, name string) string
• func InitEmptyArgumentsContext(p *ArgumentsContext)
• func InitEmptyArrayItemContext(p *ArrayItemContext)
• func InitEmptyAssignExprContext(p *AssignExprContext)
• func InitEmptyBlockContext(p *BlockContext)
• func InitEmptyCallStmtContext(p *CallStmtContext)
• func InitEmptyCodeBlockContext(p *CodeBlockContext)
• func InitEmptyComparatorContext(p *ComparatorContext)
• func InitEmptyExprContext(p *ExprContext)
• func InitEmptyFuncArgumentContext(p *FuncArgumentContext)
• func InitEmptyIfConditionContext(p *IfConditionContext)
• func InitEmptyIntegerContext(p *IntegerContext)
• func InitEmptyKeyValueContext(p *KeyValueContext)
• func InitEmptyLiteralContext(p *LiteralContext)
• func InitEmptyLvalContext(p *LvalContext)
• func InitEmptyMemberDefContext(p *MemberDefContext)
• func InitEmptyModuleContext(p *ModuleContext)
• func InitEmptyObjItemContext(p *ObjItemContext)
• func InitEmptyPostIncDecContext(p *PostIncDecContext)
• func InitEmptyPreIncDecContext(p *PreIncDecContext)
• func InitEmptyReplItemContext(p *ReplItemContext)
• func InitEmptyStmtContext(p *StmtContext)
• func InitEmptyStringLiteralContext(p *StringLiteralContext)
• func InitEmptySwitchCaseContext(p *SwitchCaseContext)
• func InitEmptySwitchDefaultContext(p *SwitchDefaultContext)
• func InitEmptyTemplateStringContext(p *TemplateStringContext)
• func InitEmptyTsItemContext(p *TsItemContext)
• func InitEmptyWhenConditionContext(p *WhenConditionContext)
• func SimpleImport(c *runtime.Context, name string, code string, importType string, ...) (modVal runtime.Value, thisTime int64, success bool)
• func ZggLexerInit()
• func ZggParserInit()
• type ArgumentsContext
  • func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext
  • func NewEmptyArgumentsContext() *ArgumentsContext
  • func (s *ArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArgumentsContext) AllCOMMA() []antlr.TerminalNode
  • func (s *ArgumentsContext) AllFuncArgument() []IFuncArgumentContext
  • func (s *ArgumentsContext) COMMA(i int) antlr.TerminalNode
  • func (s *ArgumentsContext) FuncArgument(i int) IFuncArgumentContext
  • func (s *ArgumentsContext) GetParser() antlr.Parser
  • func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext
  • func (*ArgumentsContext) IsArgumentsContext()
  • func (s *ArgumentsContext) L_PAREN() antlr.TerminalNode
  • func (s *ArgumentsContext) R_PAREN() antlr.TerminalNode
  • func (s *ArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArrayComprehensionContext
  • func NewArrayComprehensionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayComprehensionContext
  • func (s *ArrayComprehensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrayComprehensionContext) AllExpr() []IExprContext
  • func (s *ArrayComprehensionContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *ArrayComprehensionContext) COMMA() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) Expr(i int) IExprContext
  • func (s *ArrayComprehensionContext) FOR() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) GetBegin() IExprContext
  • func (s *ArrayComprehensionContext) GetEnd() IExprContext
  • func (s *ArrayComprehensionContext) GetFilter() IExprContext
  • func (s *ArrayComprehensionContext) GetIndexer() antlr.Token
  • func (s *ArrayComprehensionContext) GetItemExpr() IExprContext
  • func (s *ArrayComprehensionContext) GetRuleContext() antlr.RuleContext
  • func (s *ArrayComprehensionContext) GetValue() antlr.Token
  • func (s *ArrayComprehensionContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *ArrayComprehensionContext) IF() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) IN() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) L_BRACKET() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) RANGE_WITHOUT_END() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) RANGE_WITH_END() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) R_BRACKET() antlr.TerminalNode
  • func (s *ArrayComprehensionContext) SetBegin(v IExprContext)
  • func (s *ArrayComprehensionContext) SetEnd(v IExprContext)
  • func (s *ArrayComprehensionContext) SetFilter(v IExprContext)
  • func (s *ArrayComprehensionContext) SetIndexer(v antlr.Token)
  • func (s *ArrayComprehensionContext) SetItemExpr(v IExprContext)
  • func (s *ArrayComprehensionContext) SetValue(v antlr.Token)
• type ArrayItemContext
  • func NewArrayItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayItemContext
  • func NewEmptyArrayItemContext() *ArrayItemContext
  • func (s *ArrayItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrayItemContext) AllExpr() []IExprContext
  • func (s *ArrayItemContext) Expr(i int) IExprContext
  • func (s *ArrayItemContext) GetCondition() IExprContext
  • func (s *ArrayItemContext) GetParser() antlr.Parser
  • func (s *ArrayItemContext) GetRuleContext() antlr.RuleContext
  • func (s *ArrayItemContext) IF() antlr.TerminalNode
  • func (*ArrayItemContext) IsArrayItemContext()
  • func (s *ArrayItemContext) MORE_ARGS() antlr.TerminalNode
  • func (s *ArrayItemContext) SetCondition(v IExprContext)
  • func (s *ArrayItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AssignExistsContext
  • func NewAssignExistsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignExistsContext
  • func (s *AssignExistsContext) ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignExistsContext) BIT_AND_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) BIT_OR_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) BIT_SHL_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) BIT_SHR_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) BIT_XOR_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) DIV_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) Expr() IExprContext
  • func (s *AssignExistsContext) GetOp() antlr.Token
  • func (s *AssignExistsContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignExistsContext) Lval() ILvalContext
  • func (s *AssignExistsContext) MINUS_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) PLUS_ASSIGN() antlr.TerminalNode
  • func (s *AssignExistsContext) SetOp(v antlr.Token)
  • func (s *AssignExistsContext) TIMES_ASSIGN() antlr.TerminalNode
• type AssignExprContext
  • func NewAssignExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignExprContext
  • func NewEmptyAssignExprContext() *AssignExprContext
  • func (s *AssignExprContext) CopyAll(ctx *AssignExprContext)
  • func (s *AssignExprContext) GetParser() antlr.Parser
  • func (s *AssignExprContext) GetRuleContext() antlr.RuleContext
  • func (*AssignExprContext) IsAssignExprContext()
  • func (s *AssignExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AssignNewContext
  • func NewAssignNewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewContext
  • func (s *AssignNewContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignNewContext) Expr() IExprContext
  • func (s *AssignNewContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignNewContext) IDENTIFIER() antlr.TerminalNode
  • func (s *AssignNewContext) LOCAL_ASSIGN() antlr.TerminalNode
• type AssignNewDeArrayContext
  • func NewAssignNewDeArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewDeArrayContext
  • func (s *AssignNewDeArrayContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignNewDeArrayContext) AllCOMMA() []antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) COMMA(i int) antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) Expr() IExprContext
  • func (s *AssignNewDeArrayContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignNewDeArrayContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) LOCAL_ASSIGN() antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) L_BRACKET() antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) MORE_ARGS() antlr.TerminalNode
  • func (s *AssignNewDeArrayContext) R_BRACKET() antlr.TerminalNode
• type AssignNewDeObjectContext
  • func NewAssignNewDeObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewDeObjectContext
  • func (s *AssignNewDeObjectContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignNewDeObjectContext) AllCOMMA() []antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) AllL_CURLY() []antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) COMMA(i int) antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) Expr() IExprContext
  • func (s *AssignNewDeObjectContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignNewDeObjectContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) LOCAL_ASSIGN() antlr.TerminalNode
  • func (s *AssignNewDeObjectContext) L_CURLY(i int) antlr.TerminalNode
• type AssignNewLocalContext
  • func NewAssignNewLocalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewLocalContext
  • func (s *AssignNewLocalContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignNewLocalContext) Expr() IExprContext
  • func (s *AssignNewLocalContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignNewLocalContext) LOCAL_ASSIGN() antlr.TerminalNode
  • func (s *AssignNewLocalContext) MORE_ARGS() antlr.TerminalNode
• type BaseZggParserVisitor
  • func (v *BaseZggParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}
  • func (v *BaseZggParserVisitor) VisitArrayComprehension(ctx *ArrayComprehensionContext) interface{}
  • func (v *BaseZggParserVisitor) VisitArrayItem(ctx *ArrayItemContext) interface{}
  • func (v *BaseZggParserVisitor) VisitAssignExists(ctx *AssignExistsContext) interface{}
  • func (v *BaseZggParserVisitor) VisitAssignNew(ctx *AssignNewContext) interface{}
  • func (v *BaseZggParserVisitor) VisitAssignNewDeArray(ctx *AssignNewDeArrayContext) interface{}
  • func (v *BaseZggParserVisitor) VisitAssignNewDeObject(ctx *AssignNewDeObjectContext) interface{}
  • func (v *BaseZggParserVisitor) VisitAssignNewLocal(ctx *AssignNewLocalContext) interface{}
  • func (v *BaseZggParserVisitor) VisitBlock(ctx *BlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitCallStmt(ctx *CallStmtContext) interface{}
  • func (v *BaseZggParserVisitor) VisitCodeBlock(ctx *CodeBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitComparator(ctx *ComparatorContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprAssertError(ctx *ExprAssertErrorContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprAssign(ctx *ExprAssignContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBitAnd(ctx *ExprBitAndContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBitNot(ctx *ExprBitNotContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBitOr(ctx *ExprBitOrContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBitShift(ctx *ExprBitShiftContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBitXor(ctx *ExprBitXorContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprByField(ctx *ExprByFieldContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprByIndex(ctx *ExprByIndexContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprBySlice(ctx *ExprBySliceContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprCall(ctx *ExprCallContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprCompare(ctx *ExprCompareContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprFallback(ctx *ExprFallbackContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprIdentifier(ctx *ExprIdentifierContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprInContainer(ctx *ExprInContainerContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprInRange(ctx *ExprInRangeContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprIsType(ctx *ExprIsTypeContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprItByField(ctx *ExprItByFieldContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprLiteral(ctx *ExprLiteralContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprLogicAnd(ctx *ExprLogicAndContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprLogicNot(ctx *ExprLogicNotContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprLogicOr(ctx *ExprLogicOrContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprNegative(ctx *ExprNegativeContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprPlusMinus(ctx *ExprPlusMinusContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprPostIncDec(ctx *ExprPostIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprPow(ctx *ExprPowContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprPreIncDec(ctx *ExprPreIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprQuestion(ctx *ExprQuestionContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprShortImport(ctx *ExprShortImportContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprSub(ctx *ExprSubContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprTimesDivMod(ctx *ExprTimesDivModContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprUseBlock(ctx *ExprUseBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprUseCloser(ctx *ExprUseCloserContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprUseMethod(ctx *ExprUseMethodContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprWhen(ctx *ExprWhenContext) interface{}
  • func (v *BaseZggParserVisitor) VisitExprWhenValue(ctx *ExprWhenValueContext) interface{}
  • func (v *BaseZggParserVisitor) VisitFuncArgument(ctx *FuncArgumentContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIfCondition(ctx *IfConditionContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIntegerBin(ctx *IntegerBinContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIntegerDec(ctx *IntegerDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIntegerHex(ctx *IntegerHexContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIntegerOct(ctx *IntegerOctContext) interface{}
  • func (v *BaseZggParserVisitor) VisitIntegerZero(ctx *IntegerZeroContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVExprKey(ctx *KVExprKeyContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVExprOnly(ctx *KVExprOnlyContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVIdKey(ctx *KVIdKeyContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVIdOnly(ctx *KVIdOnlyContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVKeyFunc(ctx *KVKeyFuncContext) interface{}
  • func (v *BaseZggParserVisitor) VisitKVStrKey(ctx *KVStrKeyContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralArray(ctx *LiteralArrayContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralBigNum(ctx *LiteralBigNumContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralBool(ctx *LiteralBoolContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralENum(ctx *LiteralENumContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralFloat(ctx *LiteralFloatContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralFunc(ctx *LiteralFuncContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralInteger(ctx *LiteralIntegerContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralLambdaBlock(ctx *LiteralLambdaBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralLambdaExpr(ctx *LiteralLambdaExprContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralNil(ctx *LiteralNilContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralObject(ctx *LiteralObjectContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralString(ctx *LiteralStringContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLiteralUndefined(ctx *LiteralUndefinedContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLvalByField(ctx *LvalByFieldContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLvalById(ctx *LvalByIdContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLvalByIndex(ctx *LvalByIndexContext) interface{}
  • func (v *BaseZggParserVisitor) VisitLvalItByField(ctx *LvalItByFieldContext) interface{}
  • func (v *BaseZggParserVisitor) VisitMemberDef(ctx *MemberDefContext) interface{}
  • func (v *BaseZggParserVisitor) VisitModule(ctx *ModuleContext) interface{}
  • func (v *BaseZggParserVisitor) VisitObjItemExpanded(ctx *ObjItemExpandedContext) interface{}
  • func (v *BaseZggParserVisitor) VisitObjItemKV(ctx *ObjItemKVContext) interface{}
  • func (v *BaseZggParserVisitor) VisitObjectComprehension(ctx *ObjectComprehensionContext) interface{}
  • func (v *BaseZggParserVisitor) VisitPostIncDec(ctx *PostIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitPreIncDec(ctx *PreIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitReplBlock(ctx *ReplBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitReplExpr(ctx *ReplExprContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtAssert(ctx *StmtAssertContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtAssign(ctx *StmtAssignContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtBlock(ctx *StmtBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtBreak(ctx *StmtBreakContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtClassDefine(ctx *StmtClassDefineContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtContinue(ctx *StmtContinueContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtDefer(ctx *StmtDeferContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtDeferBlock(ctx *StmtDeferBlockContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtDoWhile(ctx *StmtDoWhileContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtExportExpr(ctx *StmtExportExprContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtExportFuncDefine(ctx *StmtExportFuncDefineContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtExportIdentifier(ctx *StmtExportIdentifierContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtExtend(ctx *StmtExtendContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtFor(ctx *StmtForContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtForEach(ctx *StmtForEachContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtFuncCall(ctx *StmtFuncCallContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtFuncDefine(ctx *StmtFuncDefineContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtIf(ctx *StmtIfContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtPostIncDec(ctx *StmtPostIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtPreIncDec(ctx *StmtPreIncDecContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtReturn(ctx *StmtReturnContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtReturnNone(ctx *StmtReturnNoneContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtSwitch(ctx *StmtSwitchContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtTry(ctx *StmtTryContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStmtWhile(ctx *StmtWhileContext) interface{}
  • func (v *BaseZggParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}
  • func (v *BaseZggParserVisitor) VisitSwitchCase(ctx *SwitchCaseContext) interface{}
  • func (v *BaseZggParserVisitor) VisitSwitchDefault(ctx *SwitchDefaultContext) interface{}
  • func (v *BaseZggParserVisitor) VisitTemplateString(ctx *TemplateStringContext) interface{}
  • func (v *BaseZggParserVisitor) VisitTsExpr(ctx *TsExprContext) interface{}
  • func (v *BaseZggParserVisitor) VisitTsIdentifier(ctx *TsIdentifierContext) interface{}
  • func (v *BaseZggParserVisitor) VisitTsRaw(ctx *TsRawContext) interface{}
  • func (v *BaseZggParserVisitor) VisitWhenConditionInList(ctx *WhenConditionInListContext) interface{}
  • func (v *BaseZggParserVisitor) VisitWhenConditionInRange(ctx *WhenConditionInRangeContext) interface{}
  • func (v *BaseZggParserVisitor) VisitWhenConditionIsType(ctx *WhenConditionIsTypeContext) interface{}
• type BlockContext
  • func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext
  • func NewEmptyBlockContext() *BlockContext
  • func (s *BlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BlockContext) AllSEMICOLON() []antlr.TerminalNode
  • func (s *BlockContext) AllStmt() []IStmtContext
  • func (s *BlockContext) GetParser() antlr.Parser
  • func (s *BlockContext) GetRuleContext() antlr.RuleContext
  • func (*BlockContext) IsBlockContext()
  • func (s *BlockContext) SEMICOLON(i int) antlr.TerminalNode
  • func (s *BlockContext) Stmt(i int) IStmtContext
  • func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CallStmtContext
  • func NewCallStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallStmtContext
  • func NewEmptyCallStmtContext() *CallStmtContext
  • func (s *CallStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CallStmtContext) Arguments() IArgumentsContext
  • func (s *CallStmtContext) CodeBlock() ICodeBlockContext
  • func (s *CallStmtContext) Expr() IExprContext
  • func (s *CallStmtContext) GetParser() antlr.Parser
  • func (s *CallStmtContext) GetRuleContext() antlr.RuleContext
  • func (*CallStmtContext) IsCallStmtContext()
  • func (s *CallStmtContext) OPTIONAL_CALL() antlr.TerminalNode
  • func (s *CallStmtContext) OPTIONAL_ELSE() antlr.TerminalNode
  • func (s *CallStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CodeBlockContext
  • func NewCodeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CodeBlockContext
  • func NewEmptyCodeBlockContext() *CodeBlockContext
  • func (s *CodeBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CodeBlockContext) Block() IBlockContext
  • func (s *CodeBlockContext) GetParser() antlr.Parser
  • func (s *CodeBlockContext) GetRuleContext() antlr.RuleContext
  • func (*CodeBlockContext) IsCodeBlockContext()
  • func (s *CodeBlockContext) L_CURLY() antlr.TerminalNode
  • func (s *CodeBlockContext) R_CURLY() antlr.TerminalNode
  • func (s *CodeBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ComparatorContext
  • func NewComparatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparatorContext
  • func NewEmptyComparatorContext() *ComparatorContext
  • func (s *ComparatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ComparatorContext) EQUAL() antlr.TerminalNode
  • func (s *ComparatorContext) GT() antlr.TerminalNode
  • func (s *ComparatorContext) GTEQ() antlr.TerminalNode
  • func (s *ComparatorContext) GetParser() antlr.Parser
  • func (s *ComparatorContext) GetRuleContext() antlr.RuleContext
  • func (*ComparatorContext) IsComparatorContext()
  • func (s *ComparatorContext) LT() antlr.TerminalNode
  • func (s *ComparatorContext) LTEQ() antlr.TerminalNode
  • func (s *ComparatorContext) NOT_EQUAL() antlr.TerminalNode
  • func (s *ComparatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExprAssertErrorContext
  • func NewExprAssertErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAssertErrorContext
  • func (s *ExprAssertErrorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprAssertErrorContext) Expr() IExprContext
  • func (s *ExprAssertErrorContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprAssertErrorContext) LOGIC_NOT() antlr.TerminalNode
• type ExprAssignContext
  • func NewExprAssignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAssignContext
  • func (s *ExprAssignContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprAssignContext) AssignExpr() IAssignExprContext
  • func (s *ExprAssignContext) GetRuleContext() antlr.RuleContext
• type ExprBitAndContext
  • func NewExprBitAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitAndContext
  • func (s *ExprBitAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBitAndContext) AllExpr() []IExprContext
  • func (s *ExprBitAndContext) BIT_AND() antlr.TerminalNode
  • func (s *ExprBitAndContext) Expr(i int) IExprContext
  • func (s *ExprBitAndContext) GetRuleContext() antlr.RuleContext
• type ExprBitNotContext
  • func NewExprBitNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitNotContext
  • func (s *ExprBitNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBitNotContext) BIT_NOT() antlr.TerminalNode
  • func (s *ExprBitNotContext) Expr() IExprContext
  • func (s *ExprBitNotContext) GetRuleContext() antlr.RuleContext
• type ExprBitOrContext
  • func NewExprBitOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitOrContext
  • func (s *ExprBitOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBitOrContext) AllExpr() []IExprContext
  • func (s *ExprBitOrContext) BIT_OR() antlr.TerminalNode
  • func (s *ExprBitOrContext) Expr(i int) IExprContext
  • func (s *ExprBitOrContext) GetRuleContext() antlr.RuleContext
• type ExprBitShiftContext
  • func NewExprBitShiftContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitShiftContext
  • func (s *ExprBitShiftContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBitShiftContext) AllExpr() []IExprContext
  • func (s *ExprBitShiftContext) BIT_SHL() antlr.TerminalNode
  • func (s *ExprBitShiftContext) BIT_SHR() antlr.TerminalNode
  • func (s *ExprBitShiftContext) Expr(i int) IExprContext
  • func (s *ExprBitShiftContext) GetOp() antlr.Token
  • func (s *ExprBitShiftContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprBitShiftContext) SetOp(v antlr.Token)
• type ExprBitXorContext
  • func NewExprBitXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitXorContext
  • func (s *ExprBitXorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBitXorContext) AllExpr() []IExprContext
  • func (s *ExprBitXorContext) BIT_XOR() antlr.TerminalNode
  • func (s *ExprBitXorContext) Expr(i int) IExprContext
  • func (s *ExprBitXorContext) GetRuleContext() antlr.RuleContext
• type ExprByFieldContext
  • func NewExprByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprByFieldContext
  • func (s *ExprByFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprByFieldContext) DOT() antlr.TerminalNode
  • func (s *ExprByFieldContext) Expr() IExprContext
  • func (s *ExprByFieldContext) GetField() antlr.Token
  • func (s *ExprByFieldContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprByFieldContext) IDENTIFIER() antlr.TerminalNode
  • func (s *ExprByFieldContext) SetField(v antlr.Token)
• type ExprByIndexContext
  • func NewExprByIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprByIndexContext
  • func (s *ExprByIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprByIndexContext) AllExpr() []IExprContext
  • func (s *ExprByIndexContext) Expr(i int) IExprContext
  • func (s *ExprByIndexContext) GetIndex() IExprContext
  • func (s *ExprByIndexContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprByIndexContext) L_BRACKET() antlr.TerminalNode
  • func (s *ExprByIndexContext) R_BRACKET() antlr.TerminalNode
  • func (s *ExprByIndexContext) SetIndex(v IExprContext)
• type ExprBySliceContext
  • func NewExprBySliceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBySliceContext
  • func (s *ExprBySliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprBySliceContext) AllExpr() []IExprContext
  • func (s *ExprBySliceContext) COLON() antlr.TerminalNode
  • func (s *ExprBySliceContext) Expr(i int) IExprContext
  • func (s *ExprBySliceContext) GetBegin() IExprContext
  • func (s *ExprBySliceContext) GetContainer() IExprContext
  • func (s *ExprBySliceContext) GetEnd() IExprContext
  • func (s *ExprBySliceContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprBySliceContext) L_BRACKET() antlr.TerminalNode
  • func (s *ExprBySliceContext) R_BRACKET() antlr.TerminalNode
  • func (s *ExprBySliceContext) SetBegin(v IExprContext)
  • func (s *ExprBySliceContext) SetContainer(v IExprContext)
  • func (s *ExprBySliceContext) SetEnd(v IExprContext)
• type ExprCallContext
  • func NewExprCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprCallContext
  • func (s *ExprCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprCallContext) Arguments() IArgumentsContext
  • func (s *ExprCallContext) Expr() IExprContext
  • func (s *ExprCallContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprCallContext) OPTIONAL_CALL() antlr.TerminalNode
• type ExprCompareContext
  • func NewExprCompareContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprCompareContext
  • func (s *ExprCompareContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprCompareContext) AllExpr() []IExprContext
  • func (s *ExprCompareContext) Comparator() IComparatorContext
  • func (s *ExprCompareContext) Expr(i int) IExprContext
  • func (s *ExprCompareContext) GetRuleContext() antlr.RuleContext
• type ExprContext
  • func NewEmptyExprContext() *ExprContext
  • func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext
  • func (s *ExprContext) CopyAll(ctx *ExprContext)
  • func (s *ExprContext) GetParser() antlr.Parser
  • func (s *ExprContext) GetRuleContext() antlr.RuleContext
  • func (*ExprContext) IsExprContext()
  • func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExprFallbackContext
  • func NewExprFallbackContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprFallbackContext
  • func (s *ExprFallbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprFallbackContext) AllExpr() []IExprContext
  • func (s *ExprFallbackContext) Expr(i int) IExprContext
  • func (s *ExprFallbackContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprFallbackContext) OPTIONAL_ELSE() antlr.TerminalNode
• type ExprIdentifierContext
  • func NewExprIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprIdentifierContext
  • func (s *ExprIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprIdentifierContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprIdentifierContext) IDENTIFIER() antlr.TerminalNode
• type ExprInContainerContext
  • func NewExprInContainerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprInContainerContext
  • func (s *ExprInContainerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprInContainerContext) AllExpr() []IExprContext
  • func (s *ExprInContainerContext) Expr(i int) IExprContext
  • func (s *ExprInContainerContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprInContainerContext) IN() antlr.TerminalNode
• type ExprInRangeContext
  • func NewExprInRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprInRangeContext
  • func (s *ExprInRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprInRangeContext) AllExpr() []IExprContext
  • func (s *ExprInRangeContext) Expr(i int) IExprContext
  • func (s *ExprInRangeContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprInRangeContext) IN() antlr.TerminalNode
  • func (s *ExprInRangeContext) RANGE_WITHOUT_END() antlr.TerminalNode
  • func (s *ExprInRangeContext) RANGE_WITH_END() antlr.TerminalNode
• type ExprIsTypeContext
  • func NewExprIsTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprIsTypeContext
  • func (s *ExprIsTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprIsTypeContext) AllExpr() []IExprContext
  • func (s *ExprIsTypeContext) Expr(i int) IExprContext
  • func (s *ExprIsTypeContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprIsTypeContext) IS() antlr.TerminalNode
• type ExprItByFieldContext
  • func NewExprItByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprItByFieldContext
  • func (s *ExprItByFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprItByFieldContext) DOT() antlr.TerminalNode
  • func (s *ExprItByFieldContext) GetField() antlr.Token
  • func (s *ExprItByFieldContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprItByFieldContext) IDENTIFIER() antlr.TerminalNode
  • func (s *ExprItByFieldContext) SetField(v antlr.Token)
• type ExprLiteralContext
  • func NewExprLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLiteralContext
  • func (s *ExprLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprLiteralContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprLiteralContext) Literal() ILiteralContext
• type ExprLogicAndContext
  • func NewExprLogicAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicAndContext
  • func (s *ExprLogicAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprLogicAndContext) AllExpr() []IExprContext
  • func (s *ExprLogicAndContext) Expr(i int) IExprContext
  • func (s *ExprLogicAndContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprLogicAndContext) LOGIC_AND() antlr.TerminalNode
• type ExprLogicNotContext
  • func NewExprLogicNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicNotContext
  • func (s *ExprLogicNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprLogicNotContext) Expr() IExprContext
  • func (s *ExprLogicNotContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprLogicNotContext) LOGIC_NOT() antlr.TerminalNode
• type ExprLogicOrContext
  • func NewExprLogicOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicOrContext
  • func (s *ExprLogicOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprLogicOrContext) AllExpr() []IExprContext
  • func (s *ExprLogicOrContext) Expr(i int) IExprContext
  • func (s *ExprLogicOrContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprLogicOrContext) LOGIC_OR() antlr.TerminalNode
• type ExprNegativeContext
  • func NewExprNegativeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprNegativeContext
  • func (s *ExprNegativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprNegativeContext) Expr() IExprContext
  • func (s *ExprNegativeContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprNegativeContext) MINUS() antlr.TerminalNode
• type ExprPlusMinusContext
  • func NewExprPlusMinusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPlusMinusContext
  • func (s *ExprPlusMinusContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprPlusMinusContext) AllExpr() []IExprContext
  • func (s *ExprPlusMinusContext) Expr(i int) IExprContext
  • func (s *ExprPlusMinusContext) GetOp() antlr.Token
  • func (s *ExprPlusMinusContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprPlusMinusContext) MINUS() antlr.TerminalNode
  • func (s *ExprPlusMinusContext) PLUS() antlr.TerminalNode
  • func (s *ExprPlusMinusContext) SetOp(v antlr.Token)
• type ExprPostIncDecContext
  • func NewExprPostIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPostIncDecContext
  • func (s *ExprPostIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprPostIncDecContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprPostIncDecContext) PostIncDec() IPostIncDecContext
• type ExprPowContext
  • func NewExprPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPowContext
  • func (s *ExprPowContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprPowContext) AllExpr() []IExprContext
  • func (s *ExprPowContext) Expr(i int) IExprContext
  • func (s *ExprPowContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprPowContext) POW() antlr.TerminalNode
• type ExprPreIncDecContext
  • func NewExprPreIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPreIncDecContext
  • func (s *ExprPreIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprPreIncDecContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprPreIncDecContext) PreIncDec() IPreIncDecContext
• type ExprQuestionContext
  • func NewExprQuestionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprQuestionContext
  • func (s *ExprQuestionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprQuestionContext) AllExpr() []IExprContext
  • func (s *ExprQuestionContext) COLON() antlr.TerminalNode
  • func (s *ExprQuestionContext) Expr(i int) IExprContext
  • func (s *ExprQuestionContext) GetCondition() IExprContext
  • func (s *ExprQuestionContext) GetFalseExpr() IExprContext
  • func (s *ExprQuestionContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprQuestionContext) GetTrueExpr() IExprContext
  • func (s *ExprQuestionContext) QUESTION() antlr.TerminalNode
  • func (s *ExprQuestionContext) SetCondition(v IExprContext)
  • func (s *ExprQuestionContext) SetFalseExpr(v IExprContext)
  • func (s *ExprQuestionContext) SetTrueExpr(v IExprContext)
• type ExprShortImportContext
  • func NewExprShortImportContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprShortImportContext
  • func (s *ExprShortImportContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprShortImportContext) DOUBLE_AT() antlr.TerminalNode
  • func (s *ExprShortImportContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprShortImportContext) IDENTIFIER() antlr.TerminalNode
  • func (s *ExprShortImportContext) SINGLE_AT() antlr.TerminalNode
• type ExprSubContext
  • func NewExprSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprSubContext
  • func (s *ExprSubContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprSubContext) Expr() IExprContext
  • func (s *ExprSubContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprSubContext) L_PAREN() antlr.TerminalNode
  • func (s *ExprSubContext) R_PAREN() antlr.TerminalNode
• type ExprTimesDivModContext
  • func NewExprTimesDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprTimesDivModContext
  • func (s *ExprTimesDivModContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprTimesDivModContext) AllExpr() []IExprContext
  • func (s *ExprTimesDivModContext) DIV() antlr.TerminalNode
  • func (s *ExprTimesDivModContext) Expr(i int) IExprContext
  • func (s *ExprTimesDivModContext) GetOp() antlr.Token
  • func (s *ExprTimesDivModContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprTimesDivModContext) MOD() antlr.TerminalNode
  • func (s *ExprTimesDivModContext) SetOp(v antlr.Token)
  • func (s *ExprTimesDivModContext) TIMES() antlr.TerminalNode
• type ExprUseBlockContext
  • func NewExprUseBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseBlockContext
  • func (s *ExprUseBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprUseBlockContext) CodeBlock() ICodeBlockContext
  • func (s *ExprUseBlockContext) Expr() IExprContext
  • func (s *ExprUseBlockContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprUseBlockContext) USE_AT() antlr.TerminalNode
• type ExprUseCloserContext
  • func NewExprUseCloserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseCloserContext
  • func (s *ExprUseCloserContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprUseCloserContext) Expr() IExprContext
  • func (s *ExprUseCloserContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprUseCloserContext) USE() antlr.TerminalNode
• type ExprUseMethodContext
  • func NewExprUseMethodContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseMethodContext
  • func (s *ExprUseMethodContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprUseMethodContext) Expr() IExprContext
  • func (s *ExprUseMethodContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprUseMethodContext) IDENTIFIER() antlr.TerminalNode
  • func (s *ExprUseMethodContext) USE_AT() antlr.TerminalNode
• type ExprWhenContext
  • func NewExprWhenContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprWhenContext
  • func (s *ExprWhenContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprWhenContext) AllExpr() []IExprContext
  • func (s *ExprWhenContext) AllLEAD_TO() []antlr.TerminalNode
  • func (s *ExprWhenContext) ELSE() antlr.TerminalNode
  • func (s *ExprWhenContext) Expr(i int) IExprContext
  • func (s *ExprWhenContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprWhenContext) LEAD_TO(i int) antlr.TerminalNode
  • func (s *ExprWhenContext) L_CURLY() antlr.TerminalNode
  • func (s *ExprWhenContext) R_CURLY() antlr.TerminalNode
  • func (s *ExprWhenContext) WHEN() antlr.TerminalNode
• type ExprWhenValueContext
  • func NewExprWhenValueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprWhenValueContext
  • func (s *ExprWhenValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExprWhenValueContext) AllExpr() []IExprContext
  • func (s *ExprWhenValueContext) AllLEAD_TO() []antlr.TerminalNode
  • func (s *ExprWhenValueContext) AllWhenCondition() []IWhenConditionContext
  • func (s *ExprWhenValueContext) ELSE() antlr.TerminalNode
  • func (s *ExprWhenValueContext) Expr(i int) IExprContext
  • func (s *ExprWhenValueContext) GetRuleContext() antlr.RuleContext
  • func (s *ExprWhenValueContext) LEAD_TO(i int) antlr.TerminalNode
  • func (s *ExprWhenValueContext) L_CURLY() antlr.TerminalNode
  • func (s *ExprWhenValueContext) R_CURLY() antlr.TerminalNode
  • func (s *ExprWhenValueContext) WHEN() antlr.TerminalNode
  • func (s *ExprWhenValueContext) WhenCondition(i int) IWhenConditionContext
• type FuncArgumentContext
  • func NewEmptyFuncArgumentContext() *FuncArgumentContext
  • func NewFuncArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FuncArgumentContext
  • func (s *FuncArgumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FuncArgumentContext) COLON() antlr.TerminalNode
  • func (s *FuncArgumentContext) CodeBlock() ICodeBlockContext
  • func (s *FuncArgumentContext) Expr() IExprContext
  • func (s *FuncArgumentContext) GetHoleIndex() antlr.Token
  • func (s *FuncArgumentContext) GetLambdaExpr() IExprContext
  • func (s *FuncArgumentContext) GetParser() antlr.Parser
  • func (s *FuncArgumentContext) GetPlaceholder() antlr.Token
  • func (s *FuncArgumentContext) GetRuleContext() antlr.RuleContext
  • func (s *FuncArgumentContext) GetSimpleArg() IExprContext
  • func (s *FuncArgumentContext) IDENTIFIER() antlr.TerminalNode
  • func (s *FuncArgumentContext) INT_DEC() antlr.TerminalNode
  • func (s *FuncArgumentContext) INT_ZERO() antlr.TerminalNode
  • func (*FuncArgumentContext) IsFuncArgumentContext()
  • func (s *FuncArgumentContext) L_CURLY() antlr.TerminalNode
  • func (s *FuncArgumentContext) MOD() antlr.TerminalNode
  • func (s *FuncArgumentContext) MORE_ARGS() antlr.TerminalNode
  • func (s *FuncArgumentContext) R_CURLY() antlr.TerminalNode
  • func (s *FuncArgumentContext) SetHoleIndex(v antlr.Token)
  • func (s *FuncArgumentContext) SetLambdaExpr(v IExprContext)
  • func (s *FuncArgumentContext) SetPlaceholder(v antlr.Token)
  • func (s *FuncArgumentContext) SetSimpleArg(v IExprContext)
  • func (s *FuncArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IArgumentsContext
• type IArrayItemContext
• type IAssignExprContext
• type IBlockContext
• type ICallStmtContext
• type ICodeBlockContext
• type IComparatorContext
• type IExprContext
• type IFuncArgumentContext
• type IIfConditionContext
• type IIntegerContext
• type IKeyValueContext
• type ILiteralContext
• type ILvalContext
• type IMemberDefContext
• type IModuleContext
• type IObjItemContext
• type IPostIncDecContext
• type IPreIncDecContext
• type IReplItemContext
• type IStmtContext
• type IStringLiteralContext
• type ISwitchCaseContext
• type ISwitchDefaultContext
• type ITemplateStringContext
• type ITsItemContext
• type IWhenConditionContext
• type IfConditionContext
  • func NewEmptyIfConditionContext() *IfConditionContext
  • func NewIfConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionContext
  • func (s *IfConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IfConditionContext) AssignExpr() IAssignExprContext
  • func (s *IfConditionContext) Expr() IExprContext
  • func (s *IfConditionContext) GetParser() antlr.Parser
  • func (s *IfConditionContext) GetRuleContext() antlr.RuleContext
  • func (*IfConditionContext) IsIfConditionContext()
  • func (s *IfConditionContext) SEMICOLON() antlr.TerminalNode
  • func (s *IfConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IntegerBinContext
  • func NewIntegerBinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerBinContext
  • func (s *IntegerBinContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IntegerBinContext) GetRuleContext() antlr.RuleContext
  • func (s *IntegerBinContext) INT_BIN() antlr.TerminalNode
• type IntegerContext
  • func NewEmptyIntegerContext() *IntegerContext
  • func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerContext
  • func (s *IntegerContext) CopyAll(ctx *IntegerContext)
  • func (s *IntegerContext) GetParser() antlr.Parser
  • func (s *IntegerContext) GetRuleContext() antlr.RuleContext
  • func (*IntegerContext) IsIntegerContext()
  • func (s *IntegerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IntegerDecContext
  • func NewIntegerDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerDecContext
  • func (s *IntegerDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IntegerDecContext) GetRuleContext() antlr.RuleContext
  • func (s *IntegerDecContext) INT_DEC() antlr.TerminalNode
• type IntegerHexContext
  • func NewIntegerHexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerHexContext
  • func (s *IntegerHexContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IntegerHexContext) GetRuleContext() antlr.RuleContext
  • func (s *IntegerHexContext) INT_HEX() antlr.TerminalNode
• type IntegerOctContext
  • func NewIntegerOctContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerOctContext
  • func (s *IntegerOctContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IntegerOctContext) GetRuleContext() antlr.RuleContext
  • func (s *IntegerOctContext) INT_OCT() antlr.TerminalNode
• type IntegerZeroContext
  • func NewIntegerZeroContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerZeroContext
  • func (s *IntegerZeroContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IntegerZeroContext) GetRuleContext() antlr.RuleContext
  • func (s *IntegerZeroContext) INT_ZERO() antlr.TerminalNode
• type KVExprKeyContext
  • func NewKVExprKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVExprKeyContext
  • func (s *KVExprKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVExprKeyContext) AllExpr() []IExprContext
  • func (s *KVExprKeyContext) COLON() antlr.TerminalNode
  • func (s *KVExprKeyContext) Expr(i int) IExprContext
  • func (s *KVExprKeyContext) GetRuleContext() antlr.RuleContext
  • func (s *KVExprKeyContext) L_BRACKET() antlr.TerminalNode
  • func (s *KVExprKeyContext) R_BRACKET() antlr.TerminalNode
• type KVExprOnlyContext
  • func NewKVExprOnlyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVExprOnlyContext
  • func (s *KVExprOnlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVExprOnlyContext) Expr() IExprContext
  • func (s *KVExprOnlyContext) GetRuleContext() antlr.RuleContext
  • func (s *KVExprOnlyContext) L_BRACKET() antlr.TerminalNode
  • func (s *KVExprOnlyContext) R_BRACKET() antlr.TerminalNode
• type KVIdKeyContext
  • func NewKVIdKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVIdKeyContext
  • func (s *KVIdKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVIdKeyContext) COLON() antlr.TerminalNode
  • func (s *KVIdKeyContext) Expr() IExprContext
  • func (s *KVIdKeyContext) GetRuleContext() antlr.RuleContext
  • func (s *KVIdKeyContext) IDENTIFIER() antlr.TerminalNode
• type KVIdOnlyContext
  • func NewKVIdOnlyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVIdOnlyContext
  • func (s *KVIdOnlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVIdOnlyContext) GetRuleContext() antlr.RuleContext
  • func (s *KVIdOnlyContext) IDENTIFIER() antlr.TerminalNode
• type KVKeyFuncContext
  • func NewKVKeyFuncContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVKeyFuncContext
  • func (s *KVKeyFuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVKeyFuncContext) AllCOMMA() []antlr.TerminalNode
  • func (s *KVKeyFuncContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *KVKeyFuncContext) COMMA(i int) antlr.TerminalNode
  • func (s *KVKeyFuncContext) CodeBlock() ICodeBlockContext
  • func (s *KVKeyFuncContext) GetRuleContext() antlr.RuleContext
  • func (s *KVKeyFuncContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *KVKeyFuncContext) L_PAREN() antlr.TerminalNode
  • func (s *KVKeyFuncContext) MORE_ARGS() antlr.TerminalNode
  • func (s *KVKeyFuncContext) R_PAREN() antlr.TerminalNode
• type KVStrKeyContext
  • func NewKVStrKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVStrKeyContext
  • func (s *KVStrKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KVStrKeyContext) COLON() antlr.TerminalNode
  • func (s *KVStrKeyContext) Expr() IExprContext
  • func (s *KVStrKeyContext) GetRuleContext() antlr.RuleContext
  • func (s *KVStrKeyContext) StringLiteral() IStringLiteralContext
• type KeyValueContext
  • func NewEmptyKeyValueContext() *KeyValueContext
  • func NewKeyValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyValueContext
  • func (s *KeyValueContext) CopyAll(ctx *KeyValueContext)
  • func (s *KeyValueContext) GetParser() antlr.Parser
  • func (s *KeyValueContext) GetRuleContext() antlr.RuleContext
  • func (*KeyValueContext) IsKeyValueContext()
  • func (s *KeyValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LiteralArrayContext
  • func NewLiteralArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralArrayContext
  • func (s *LiteralArrayContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralArrayContext) AllArrayItem() []IArrayItemContext
  • func (s *LiteralArrayContext) AllCOMMA() []antlr.TerminalNode
  • func (s *LiteralArrayContext) ArrayItem(i int) IArrayItemContext
  • func (s *LiteralArrayContext) COMMA(i int) antlr.TerminalNode
  • func (s *LiteralArrayContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralArrayContext) L_BRACKET() antlr.TerminalNode
  • func (s *LiteralArrayContext) R_BRACKET() antlr.TerminalNode
• type LiteralBigNumContext
  • func NewLiteralBigNumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralBigNumContext
  • func (s *LiteralBigNumContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralBigNumContext) BIGNUM() antlr.TerminalNode
  • func (s *LiteralBigNumContext) GetRuleContext() antlr.RuleContext
• type LiteralBoolContext
  • func NewLiteralBoolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralBoolContext
  • func (s *LiteralBoolContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralBoolContext) FALSE() antlr.TerminalNode
  • func (s *LiteralBoolContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralBoolContext) TRUE() antlr.TerminalNode
• type LiteralContext
  • func NewEmptyLiteralContext() *LiteralContext
  • func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext
  • func (s *LiteralContext) CopyAll(ctx *LiteralContext)
  • func (s *LiteralContext) GetParser() antlr.Parser
  • func (s *LiteralContext) GetRuleContext() antlr.RuleContext
  • func (*LiteralContext) IsLiteralContext()
  • func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LiteralENumContext
  • func NewLiteralENumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralENumContext
  • func (s *LiteralENumContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralENumContext) ENUM() antlr.TerminalNode
  • func (s *LiteralENumContext) GetRuleContext() antlr.RuleContext
• type LiteralFloatContext
  • func NewLiteralFloatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralFloatContext
  • func (s *LiteralFloatContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralFloatContext) FLOAT() antlr.TerminalNode
  • func (s *LiteralFloatContext) GetRuleContext() antlr.RuleContext
• type LiteralFuncContext
  • func NewLiteralFuncContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralFuncContext
  • func (s *LiteralFuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralFuncContext) AllCOMMA() []antlr.TerminalNode
  • func (s *LiteralFuncContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *LiteralFuncContext) COMMA(i int) antlr.TerminalNode
  • func (s *LiteralFuncContext) CodeBlock() ICodeBlockContext
  • func (s *LiteralFuncContext) FUNC() antlr.TerminalNode
  • func (s *LiteralFuncContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralFuncContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *LiteralFuncContext) L_PAREN() antlr.TerminalNode
  • func (s *LiteralFuncContext) MORE_ARGS() antlr.TerminalNode
  • func (s *LiteralFuncContext) R_PAREN() antlr.TerminalNode
• type LiteralIntegerContext
  • func NewLiteralIntegerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralIntegerContext
  • func (s *LiteralIntegerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralIntegerContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralIntegerContext) Integer() IIntegerContext
• type LiteralLambdaBlockContext
  • func NewLiteralLambdaBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralLambdaBlockContext
  • func (s *LiteralLambdaBlockContext) ARROW() antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralLambdaBlockContext) AllCOMMA() []antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) COMMA(i int) antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) CodeBlock() ICodeBlockContext
  • func (s *LiteralLambdaBlockContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralLambdaBlockContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) L_PAREN() antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) MORE_ARGS() antlr.TerminalNode
  • func (s *LiteralLambdaBlockContext) R_PAREN() antlr.TerminalNode
• type LiteralLambdaExprContext
  • func NewLiteralLambdaExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralLambdaExprContext
  • func (s *LiteralLambdaExprContext) ARROW() antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralLambdaExprContext) AllCOMMA() []antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) COMMA(i int) antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) Expr() IExprContext
  • func (s *LiteralLambdaExprContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralLambdaExprContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) L_PAREN() antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) MORE_ARGS() antlr.TerminalNode
  • func (s *LiteralLambdaExprContext) R_PAREN() antlr.TerminalNode
• type LiteralNilContext
  • func NewLiteralNilContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralNilContext
  • func (s *LiteralNilContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralNilContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralNilContext) NIL() antlr.TerminalNode
• type LiteralObjectContext
  • func NewLiteralObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralObjectContext
  • func (s *LiteralObjectContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralObjectContext) AllCOMMA() []antlr.TerminalNode
  • func (s *LiteralObjectContext) AllObjItem() []IObjItemContext
  • func (s *LiteralObjectContext) COMMA(i int) antlr.TerminalNode
  • func (s *LiteralObjectContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralObjectContext) L_CURLY() antlr.TerminalNode
  • func (s *LiteralObjectContext) ObjItem(i int) IObjItemContext
  • func (s *LiteralObjectContext) R_CURLY() antlr.TerminalNode
• type LiteralStringContext
  • func NewLiteralStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralStringContext
  • func (s *LiteralStringContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralStringContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralStringContext) StringLiteral() IStringLiteralContext
• type LiteralUndefinedContext
  • func NewLiteralUndefinedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralUndefinedContext
  • func (s *LiteralUndefinedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralUndefinedContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralUndefinedContext) UNDEFINED() antlr.TerminalNode
• type LvalByFieldContext
  • func NewLvalByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByFieldContext
  • func (s *LvalByFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LvalByFieldContext) DOT() antlr.TerminalNode
  • func (s *LvalByFieldContext) GetField() antlr.Token
  • func (s *LvalByFieldContext) GetRuleContext() antlr.RuleContext
  • func (s *LvalByFieldContext) IDENTIFIER() antlr.TerminalNode
  • func (s *LvalByFieldContext) Lval() ILvalContext
  • func (s *LvalByFieldContext) SetField(v antlr.Token)
• type LvalByIdContext
  • func NewLvalByIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByIdContext
  • func (s *LvalByIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LvalByIdContext) GetRuleContext() antlr.RuleContext
  • func (s *LvalByIdContext) IDENTIFIER() antlr.TerminalNode
• type LvalByIndexContext
  • func NewLvalByIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByIndexContext
  • func (s *LvalByIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LvalByIndexContext) Expr() IExprContext
  • func (s *LvalByIndexContext) GetIndex() IExprContext
  • func (s *LvalByIndexContext) GetRuleContext() antlr.RuleContext
  • func (s *LvalByIndexContext) L_BRACKET() antlr.TerminalNode
  • func (s *LvalByIndexContext) Lval() ILvalContext
  • func (s *LvalByIndexContext) R_BRACKET() antlr.TerminalNode
  • func (s *LvalByIndexContext) SetIndex(v IExprContext)
• type LvalContext
  • func NewEmptyLvalContext() *LvalContext
  • func NewLvalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LvalContext
  • func (s *LvalContext) CopyAll(ctx *LvalContext)
  • func (s *LvalContext) GetParser() antlr.Parser
  • func (s *LvalContext) GetRuleContext() antlr.RuleContext
  • func (*LvalContext) IsLvalContext()
  • func (s *LvalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LvalItByFieldContext
  • func NewLvalItByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalItByFieldContext
  • func (s *LvalItByFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LvalItByFieldContext) DOT() antlr.TerminalNode
  • func (s *LvalItByFieldContext) GetField() antlr.Token
  • func (s *LvalItByFieldContext) GetRuleContext() antlr.RuleContext
  • func (s *LvalItByFieldContext) IDENTIFIER() antlr.TerminalNode
  • func (s *LvalItByFieldContext) SetField(v antlr.Token)
• type MemberDefContext
  • func NewEmptyMemberDefContext() *MemberDefContext
  • func NewMemberDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberDefContext
  • func (s *MemberDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MemberDefContext) GetParser() antlr.Parser
  • func (s *MemberDefContext) GetRuleContext() antlr.RuleContext
  • func (*MemberDefContext) IsMemberDefContext()
  • func (s *MemberDefContext) KeyValue() IKeyValueContext
  • func (s *MemberDefContext) STATIC() antlr.TerminalNode
  • func (s *MemberDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ModuleContext
  • func NewEmptyModuleContext() *ModuleContext
  • func NewModuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleContext
  • func (s *ModuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ModuleContext) Block() IBlockContext
  • func (s *ModuleContext) GetParser() antlr.Parser
  • func (s *ModuleContext) GetRuleContext() antlr.RuleContext
  • func (*ModuleContext) IsModuleContext()
  • func (s *ModuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ObjItemContext
  • func NewEmptyObjItemContext() *ObjItemContext
  • func NewObjItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjItemContext
  • func (s *ObjItemContext) CopyAll(ctx *ObjItemContext)
  • func (s *ObjItemContext) GetParser() antlr.Parser
  • func (s *ObjItemContext) GetRuleContext() antlr.RuleContext
  • func (*ObjItemContext) IsObjItemContext()
  • func (s *ObjItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ObjItemExpandedContext
  • func NewObjItemExpandedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjItemExpandedContext
  • func (s *ObjItemExpandedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ObjItemExpandedContext) Expr() IExprContext
  • func (s *ObjItemExpandedContext) GetRuleContext() antlr.RuleContext
  • func (s *ObjItemExpandedContext) MORE_ARGS() antlr.TerminalNode
• type ObjItemKVContext
  • func NewObjItemKVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjItemKVContext
  • func (s *ObjItemKVContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ObjItemKVContext) GetRuleContext() antlr.RuleContext
  • func (s *ObjItemKVContext) KeyValue() IKeyValueContext
• type ObjectComprehensionContext
  • func NewObjectComprehensionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectComprehensionContext
  • func (s *ObjectComprehensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ObjectComprehensionContext) AllExpr() []IExprContext
  • func (s *ObjectComprehensionContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *ObjectComprehensionContext) COLON() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) COMMA() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) Expr(i int) IExprContext
  • func (s *ObjectComprehensionContext) FOR() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) GetBegin() IExprContext
  • func (s *ObjectComprehensionContext) GetEnd() IExprContext
  • func (s *ObjectComprehensionContext) GetFilter() IExprContext
  • func (s *ObjectComprehensionContext) GetIndexer() antlr.Token
  • func (s *ObjectComprehensionContext) GetKeyExpr() IExprContext
  • func (s *ObjectComprehensionContext) GetRuleContext() antlr.RuleContext
  • func (s *ObjectComprehensionContext) GetValue() antlr.Token
  • func (s *ObjectComprehensionContext) GetValueExpr() IExprContext
  • func (s *ObjectComprehensionContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *ObjectComprehensionContext) IF() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) IN() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) L_CURLY() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) RANGE_WITHOUT_END() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) RANGE_WITH_END() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) R_CURLY() antlr.TerminalNode
  • func (s *ObjectComprehensionContext) SetBegin(v IExprContext)
  • func (s *ObjectComprehensionContext) SetEnd(v IExprContext)
  • func (s *ObjectComprehensionContext) SetFilter(v IExprContext)
  • func (s *ObjectComprehensionContext) SetIndexer(v antlr.Token)
  • func (s *ObjectComprehensionContext) SetKeyExpr(v IExprContext)
  • func (s *ObjectComprehensionContext) SetValue(v antlr.Token)
  • func (s *ObjectComprehensionContext) SetValueExpr(v IExprContext)
• type ParseVisitor
  • func (v *ParseVisitor) Init()
  • func (v *ParseVisitor) VisitArguments(ctx *ArgumentsContext) interface{}
  • func (v *ParseVisitor) VisitArrayComprehension(ctx *ArrayComprehensionContext) interface{}
  • func (v *ParseVisitor) VisitArrayItem(ctx *ArrayItemContext) interface{}
  • func (v *ParseVisitor) VisitAssignExists(ctx *AssignExistsContext) interface{}
  • func (v *ParseVisitor) VisitAssignNew(ctx *AssignNewContext) interface{}
  • func (v *ParseVisitor) VisitAssignNewDeArray(ctx *AssignNewDeArrayContext) interface{}
  • func (v *ParseVisitor) VisitAssignNewDeObject(ctx *AssignNewDeObjectContext) interface{}
  • func (v *ParseVisitor) VisitAssignNewLocal(ctx *AssignNewLocalContext) interface{}
  • func (v *ParseVisitor) VisitBlock(ctx *BlockContext) interface{}
  • func (v *ParseVisitor) VisitCallStmt(ctx *CallStmtContext) interface{}
  • func (v *ParseVisitor) VisitCodeBlock(ctx *CodeBlockContext) interface{}
  • func (v *ParseVisitor) VisitExprAssertError(ctx *ExprAssertErrorContext) interface{}
  • func (v *ParseVisitor) VisitExprAssign(ctx *ExprAssignContext) interface{}
  • func (v *ParseVisitor) VisitExprBitAnd(ctx *ExprBitAndContext) interface{}
  • func (v *ParseVisitor) VisitExprBitNot(ctx *ExprBitNotContext) interface{}
  • func (v *ParseVisitor) VisitExprBitOr(ctx *ExprBitOrContext) interface{}
  • func (v *ParseVisitor) VisitExprBitShift(ctx *ExprBitShiftContext) interface{}
  • func (v *ParseVisitor) VisitExprBitXor(ctx *ExprBitXorContext) interface{}
  • func (v *ParseVisitor) VisitExprByField(ctx *ExprByFieldContext) interface{}
  • func (v *ParseVisitor) VisitExprByIndex(ctx *ExprByIndexContext) interface{}
  • func (v *ParseVisitor) VisitExprBySlice(ctx *ExprBySliceContext) interface{}
  • func (v *ParseVisitor) VisitExprCall(ctx *ExprCallContext) interface{}
  • func (v *ParseVisitor) VisitExprCompare(ctx *ExprCompareContext) interface{}
  • func (v *ParseVisitor) VisitExprFallback(ctx *ExprFallbackContext) interface{}
  • func (v *ParseVisitor) VisitExprIdentifier(ctx *ExprIdentifierContext) interface{}
  • func (v *ParseVisitor) VisitExprInContainer(ctx *ExprInContainerContext) interface{}
  • func (v *ParseVisitor) VisitExprInRange(ctx *ExprInRangeContext) interface{}
  • func (v *ParseVisitor) VisitExprIsType(ctx *ExprIsTypeContext) interface{}
  • func (v *ParseVisitor) VisitExprItByField(ctx *ExprItByFieldContext) interface{}
  • func (v *ParseVisitor) VisitExprLiteral(ctx *ExprLiteralContext) interface{}
  • func (v *ParseVisitor) VisitExprLogicAnd(ctx *ExprLogicAndContext) interface{}
  • func (v *ParseVisitor) VisitExprLogicNot(ctx *ExprLogicNotContext) interface{}
  • func (v *ParseVisitor) VisitExprLogicOr(ctx *ExprLogicOrContext) interface{}
  • func (v *ParseVisitor) VisitExprNegative(ctx *ExprNegativeContext) interface{}
  • func (v *ParseVisitor) VisitExprPlusMinus(ctx *ExprPlusMinusContext) interface{}
  • func (v *ParseVisitor) VisitExprPostIncDec(ctx *ExprPostIncDecContext) interface{}
  • func (v *ParseVisitor) VisitExprPow(ctx *ExprPowContext) interface{}
  • func (v *ParseVisitor) VisitExprPreIncDec(ctx *ExprPreIncDecContext) interface{}
  • func (v *ParseVisitor) VisitExprQuestion(ctx *ExprQuestionContext) interface{}
  • func (v *ParseVisitor) VisitExprShortImport(ctx *ExprShortImportContext) interface{}
  • func (v *ParseVisitor) VisitExprSub(ctx *ExprSubContext) interface{}
  • func (v *ParseVisitor) VisitExprTimesDivMod(ctx *ExprTimesDivModContext) interface{}
  • func (v *ParseVisitor) VisitExprUseBlock(ctx *ExprUseBlockContext) interface{}
  • func (v *ParseVisitor) VisitExprUseCloser(ctx *ExprUseCloserContext) interface{}
  • func (v *ParseVisitor) VisitExprUseMethod(ctx *ExprUseMethodContext) interface{}
  • func (v *ParseVisitor) VisitExprWhen(ctx *ExprWhenContext) interface{}
  • func (v *ParseVisitor) VisitExprWhenValue(ctx *ExprWhenValueContext) interface{}
  • func (v *ParseVisitor) VisitFuncArgument(ctx *FuncArgumentContext) interface{}
  • func (v *ParseVisitor) VisitIfCondition(ctx *IfConditionContext) interface{}
  • func (v *ParseVisitor) VisitIntegerBin(ctx *IntegerBinContext) interface{}
  • func (v *ParseVisitor) VisitIntegerDec(ctx *IntegerDecContext) interface{}
  • func (v *ParseVisitor) VisitIntegerHex(ctx *IntegerHexContext) interface{}
  • func (v *ParseVisitor) VisitIntegerOct(ctx *IntegerOctContext) interface{}
  • func (v *ParseVisitor) VisitIntegerZero(ctx *IntegerZeroContext) interface{}
  • func (v *ParseVisitor) VisitKVExprKey(ctx *KVExprKeyContext) interface{}
  • func (v *ParseVisitor) VisitKVExprOnly(ctx *KVExprOnlyContext) interface{}
  • func (v *ParseVisitor) VisitKVIdKey(ctx *KVIdKeyContext) interface{}
  • func (v *ParseVisitor) VisitKVIdOnly(ctx *KVIdOnlyContext) interface{}
  • func (v *ParseVisitor) VisitKVKeyFunc(ctx *KVKeyFuncContext) interface{}
  • func (v *ParseVisitor) VisitKVStrKey(ctx *KVStrKeyContext) interface{}
  • func (v *ParseVisitor) VisitLiteralArray(ctx *LiteralArrayContext) interface{}
  • func (v *ParseVisitor) VisitLiteralBigNum(ctx *LiteralBigNumContext) interface{}
  • func (v *ParseVisitor) VisitLiteralBool(ctx *LiteralBoolContext) interface{}
  • func (v *ParseVisitor) VisitLiteralENum(ctx *LiteralENumContext) interface{}
  • func (v *ParseVisitor) VisitLiteralFloat(ctx *LiteralFloatContext) interface{}
  • func (v *ParseVisitor) VisitLiteralFunc(ctx *LiteralFuncContext) interface{}
  • func (v *ParseVisitor) VisitLiteralInteger(ctx *LiteralIntegerContext) interface{}
  • func (v *ParseVisitor) VisitLiteralLambdaBlock(ctx *LiteralLambdaBlockContext) interface{}
  • func (v *ParseVisitor) VisitLiteralLambdaExpr(ctx *LiteralLambdaExprContext) interface{}
  • func (v *ParseVisitor) VisitLiteralNil(ctx *LiteralNilContext) interface{}
  • func (v *ParseVisitor) VisitLiteralObject(ctx *LiteralObjectContext) interface{}
  • func (v *ParseVisitor) VisitLiteralString(ctx *LiteralStringContext) interface{}
  • func (v *ParseVisitor) VisitLiteralUndefined(ctx *LiteralUndefinedContext) interface{}
  • func (v *ParseVisitor) VisitLvalByField(ctx *LvalByFieldContext) interface{}
  • func (v *ParseVisitor) VisitLvalById(ctx *LvalByIdContext) interface{}
  • func (v *ParseVisitor) VisitLvalByIndex(ctx *LvalByIndexContext) interface{}
  • func (v *ParseVisitor) VisitLvalItByField(ctx *LvalItByFieldContext) interface{}
  • func (v *ParseVisitor) VisitMemberDef(ctx *MemberDefContext) interface{}
  • func (v *ParseVisitor) VisitModule(ctx *ModuleContext) interface{}
  • func (v *ParseVisitor) VisitObjItemExpanded(ctx *ObjItemExpandedContext) interface{}
  • func (v *ParseVisitor) VisitObjItemKV(ctx *ObjItemKVContext) interface{}
  • func (v *ParseVisitor) VisitObjectComprehension(ctx *ObjectComprehensionContext) interface{}
  • func (v *ParseVisitor) VisitPostIncDec(ctx *PostIncDecContext) interface{}
  • func (v *ParseVisitor) VisitPreIncDec(ctx *PreIncDecContext) interface{}
  • func (v *ParseVisitor) VisitReplBlock(ctx *ReplBlockContext) interface{}
  • func (v *ParseVisitor) VisitReplExpr(ctx *ReplExprContext) interface{}
  • func (v *ParseVisitor) VisitStmtAssert(ctx *StmtAssertContext) interface{}
  • func (v *ParseVisitor) VisitStmtAssign(ctx *StmtAssignContext) interface{}
  • func (v *ParseVisitor) VisitStmtBlock(ctx *StmtBlockContext) interface{}
  • func (v *ParseVisitor) VisitStmtBreak(ctx *StmtBreakContext) interface{}
  • func (v *ParseVisitor) VisitStmtClassDefine(ctx *StmtClassDefineContext) interface{}
  • func (v *ParseVisitor) VisitStmtContinue(ctx *StmtContinueContext) interface{}
  • func (v *ParseVisitor) VisitStmtDefer(ctx *StmtDeferContext) interface{}
  • func (v *ParseVisitor) VisitStmtDeferBlock(ctx *StmtDeferBlockContext) interface{}
  • func (v *ParseVisitor) VisitStmtDoWhile(ctx *StmtDoWhileContext) interface{}
  • func (v *ParseVisitor) VisitStmtExportExpr(ctx *StmtExportExprContext) interface{}
  • func (v *ParseVisitor) VisitStmtExportFuncDefine(ctx *StmtExportFuncDefineContext) interface{}
  • func (v *ParseVisitor) VisitStmtExportIdentifier(ctx *StmtExportIdentifierContext) interface{}
  • func (v *ParseVisitor) VisitStmtExtend(ctx *StmtExtendContext) interface{}
  • func (v *ParseVisitor) VisitStmtFor(ctx *StmtForContext) interface{}
  • func (v *ParseVisitor) VisitStmtForEach(ctx *StmtForEachContext) interface{}
  • func (v *ParseVisitor) VisitStmtFuncCall(ctx *StmtFuncCallContext) interface{}
  • func (v *ParseVisitor) VisitStmtFuncDefine(ctx *StmtFuncDefineContext) interface{}
  • func (v *ParseVisitor) VisitStmtIf(ctx *StmtIfContext) interface{}
  • func (v *ParseVisitor) VisitStmtPostIncDec(ctx *StmtPostIncDecContext) interface{}
  • func (v *ParseVisitor) VisitStmtPreIncDec(ctx *StmtPreIncDecContext) interface{}
  • func (v *ParseVisitor) VisitStmtReturn(ctx *StmtReturnContext) interface{}
  • func (v *ParseVisitor) VisitStmtReturnNone(ctx *StmtReturnNoneContext) interface{}
  • func (v *ParseVisitor) VisitStmtSwitch(ctx *StmtSwitchContext) interface{}
  • func (v *ParseVisitor) VisitStmtTry(ctx *StmtTryContext) interface{}
  • func (v *ParseVisitor) VisitStmtWhile(ctx *StmtWhileContext) interface{}
  • func (v *ParseVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}
  • func (v *ParseVisitor) VisitTemplateString(ctx *TemplateStringContext) interface{}
  • func (v *ParseVisitor) VisitTsExpr(ctx *TsExprContext) interface{}
  • func (v *ParseVisitor) VisitTsIdentifier(ctx *TsIdentifierContext) interface{}
  • func (v *ParseVisitor) VisitTsRaw(ctx *TsRawContext) interface{}
  • func (v *ParseVisitor) VisitWhenConditionInList(ctx *WhenConditionInListContext) interface{}
  • func (v *ParseVisitor) VisitWhenConditionInRange(ctx *WhenConditionInRangeContext) interface{}
  • func (v *ParseVisitor) VisitWhenConditionIsType(ctx *WhenConditionIsTypeContext) interface{}
• type PostIncDecContext
  • func NewEmptyPostIncDecContext() *PostIncDecContext
  • func NewPostIncDecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostIncDecContext
  • func (s *PostIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PostIncDecContext) GetOp() antlr.Token
  • func (s *PostIncDecContext) GetParser() antlr.Parser
  • func (s *PostIncDecContext) GetRuleContext() antlr.RuleContext
  • func (*PostIncDecContext) IsPostIncDecContext()
  • func (s *PostIncDecContext) Lval() ILvalContext
  • func (s *PostIncDecContext) MINUS_MINUS() antlr.TerminalNode
  • func (s *PostIncDecContext) PLUS_PLUS() antlr.TerminalNode
  • func (s *PostIncDecContext) SetOp(v antlr.Token)
  • func (s *PostIncDecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type PreIncDecContext
  • func NewEmptyPreIncDecContext() *PreIncDecContext
  • func NewPreIncDecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreIncDecContext
  • func (s *PreIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PreIncDecContext) GetOp() antlr.Token
  • func (s *PreIncDecContext) GetParser() antlr.Parser
  • func (s *PreIncDecContext) GetRuleContext() antlr.RuleContext
  • func (*PreIncDecContext) IsPreIncDecContext()
  • func (s *PreIncDecContext) Lval() ILvalContext
  • func (s *PreIncDecContext) MINUS_MINUS() antlr.TerminalNode
  • func (s *PreIncDecContext) PLUS_PLUS() antlr.TerminalNode
  • func (s *PreIncDecContext) SetOp(v antlr.Token)
  • func (s *PreIncDecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ReplBlockContext
  • func NewReplBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplBlockContext
  • func (s *ReplBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ReplBlockContext) Block() IBlockContext
  • func (s *ReplBlockContext) GetRuleContext() antlr.RuleContext
• type ReplExprContext
  • func NewReplExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplExprContext
  • func (s *ReplExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ReplExprContext) Expr() IExprContext
  • func (s *ReplExprContext) GetRuleContext() antlr.RuleContext
• type ReplItemContext
  • func NewEmptyReplItemContext() *ReplItemContext
  • func NewReplItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplItemContext
  • func (s *ReplItemContext) CopyAll(ctx *ReplItemContext)
  • func (s *ReplItemContext) GetParser() antlr.Parser
  • func (s *ReplItemContext) GetRuleContext() antlr.RuleContext
  • func (*ReplItemContext) IsReplItemContext()
  • func (s *ReplItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type StmtAssertContext
  • func NewStmtAssertContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtAssertContext
  • func (s *StmtAssertContext) ASSERT() antlr.TerminalNode
  • func (s *StmtAssertContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtAssertContext) AllExpr() []IExprContext
  • func (s *StmtAssertContext) COMMA() antlr.TerminalNode
  • func (s *StmtAssertContext) Expr(i int) IExprContext
  • func (s *StmtAssertContext) GetRuleContext() antlr.RuleContext
• type StmtAssignContext
  • func NewStmtAssignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtAssignContext
  • func (s *StmtAssignContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtAssignContext) AssignExpr() IAssignExprContext
  • func (s *StmtAssignContext) GetRuleContext() antlr.RuleContext
• type StmtBlockContext
  • func NewStmtBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtBlockContext
  • func (s *StmtBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtBlockContext) CodeBlock() ICodeBlockContext
  • func (s *StmtBlockContext) GetRuleContext() antlr.RuleContext
• type StmtBreakContext
  • func NewStmtBreakContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtBreakContext
  • func (s *StmtBreakContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtBreakContext) BREAK() antlr.TerminalNode
  • func (s *StmtBreakContext) GetLabel() antlr.Token
  • func (s *StmtBreakContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtBreakContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtBreakContext) SetLabel(v antlr.Token)
• type StmtClassDefineContext
  • func NewStmtClassDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtClassDefineContext
  • func (s *StmtClassDefineContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtClassDefineContext) AllExpr() []IExprContext
  • func (s *StmtClassDefineContext) AllMemberDef() []IMemberDefContext
  • func (s *StmtClassDefineContext) CLASS() antlr.TerminalNode
  • func (s *StmtClassDefineContext) COMMA() antlr.TerminalNode
  • func (s *StmtClassDefineContext) EXPORT() antlr.TerminalNode
  • func (s *StmtClassDefineContext) Expr(i int) IExprContext
  • func (s *StmtClassDefineContext) GetBaseCls() []IExprContext
  • func (s *StmtClassDefineContext) GetClassName() antlr.Token
  • func (s *StmtClassDefineContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtClassDefineContext) Get_expr() IExprContext
  • func (s *StmtClassDefineContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtClassDefineContext) L_CURLY() antlr.TerminalNode
  • func (s *StmtClassDefineContext) L_PAREN() antlr.TerminalNode
  • func (s *StmtClassDefineContext) MemberDef(i int) IMemberDefContext
  • func (s *StmtClassDefineContext) R_CURLY() antlr.TerminalNode
  • func (s *StmtClassDefineContext) R_PAREN() antlr.TerminalNode
  • func (s *StmtClassDefineContext) SetBaseCls(v []IExprContext)
  • func (s *StmtClassDefineContext) SetClassName(v antlr.Token)
  • func (s *StmtClassDefineContext) Set_expr(v IExprContext)
• type StmtContext
  • func NewEmptyStmtContext() *StmtContext
  • func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext
  • func (s *StmtContext) CopyAll(ctx *StmtContext)
  • func (s *StmtContext) GetParser() antlr.Parser
  • func (s *StmtContext) GetRuleContext() antlr.RuleContext
  • func (*StmtContext) IsStmtContext()
  • func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type StmtContinueContext
  • func NewStmtContinueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtContinueContext
  • func (s *StmtContinueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtContinueContext) CONTINUE() antlr.TerminalNode
  • func (s *StmtContinueContext) GetLabel() antlr.Token
  • func (s *StmtContinueContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtContinueContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtContinueContext) SetLabel(v antlr.Token)
• type StmtDeferBlockContext
  • func NewStmtDeferBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDeferBlockContext
  • func (s *StmtDeferBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtDeferBlockContext) BLOCK_DEFER() antlr.TerminalNode
  • func (s *StmtDeferBlockContext) CodeBlock() ICodeBlockContext
  • func (s *StmtDeferBlockContext) DEFER() antlr.TerminalNode
  • func (s *StmtDeferBlockContext) GetRuleContext() antlr.RuleContext
• type StmtDeferContext
  • func NewStmtDeferContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDeferContext
  • func (s *StmtDeferContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtDeferContext) Arguments() IArgumentsContext
  • func (s *StmtDeferContext) BLOCK_DEFER() antlr.TerminalNode
  • func (s *StmtDeferContext) DEFER() antlr.TerminalNode
  • func (s *StmtDeferContext) Expr() IExprContext
  • func (s *StmtDeferContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtDeferContext) OPTIONAL_CALL() antlr.TerminalNode
• type StmtDoWhileContext
  • func NewStmtDoWhileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDoWhileContext
  • func (s *StmtDoWhileContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtDoWhileContext) COLON() antlr.TerminalNode
  • func (s *StmtDoWhileContext) CodeBlock() ICodeBlockContext
  • func (s *StmtDoWhileContext) DO() antlr.TerminalNode
  • func (s *StmtDoWhileContext) Expr() IExprContext
  • func (s *StmtDoWhileContext) GetCheckExpr() IExprContext
  • func (s *StmtDoWhileContext) GetExecBlock() ICodeBlockContext
  • func (s *StmtDoWhileContext) GetLabel() antlr.Token
  • func (s *StmtDoWhileContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtDoWhileContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtDoWhileContext) SetCheckExpr(v IExprContext)
  • func (s *StmtDoWhileContext) SetExecBlock(v ICodeBlockContext)
  • func (s *StmtDoWhileContext) SetLabel(v antlr.Token)
  • func (s *StmtDoWhileContext) WHILE() antlr.TerminalNode
• type StmtExportExprContext
  • func NewStmtExportExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportExprContext
  • func (s *StmtExportExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtExportExprContext) EXPORT() antlr.TerminalNode
  • func (s *StmtExportExprContext) Expr() IExprContext
  • func (s *StmtExportExprContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtExportExprContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtExportExprContext) LOCAL_ASSIGN() antlr.TerminalNode
• type StmtExportFuncDefineContext
  • func NewStmtExportFuncDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportFuncDefineContext
  • func (s *StmtExportFuncDefineContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtExportFuncDefineContext) AllCOMMA() []antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) COMMA(i int) antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) CodeBlock() ICodeBlockContext
  • func (s *StmtExportFuncDefineContext) EXPORT() antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) FUNC() antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtExportFuncDefineContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) L_PAREN() antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) MORE_ARGS() antlr.TerminalNode
  • func (s *StmtExportFuncDefineContext) R_PAREN() antlr.TerminalNode
• type StmtExportIdentifierContext
  • func NewStmtExportIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportIdentifierContext
  • func (s *StmtExportIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtExportIdentifierContext) EXPORT() antlr.TerminalNode
  • func (s *StmtExportIdentifierContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtExportIdentifierContext) IDENTIFIER() antlr.TerminalNode
• type StmtExtendContext
  • func NewStmtExtendContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExtendContext
  • func (s *StmtExtendContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtExtendContext) AllKeyValue() []IKeyValueContext
  • func (s *StmtExtendContext) EXPORT() antlr.TerminalNode
  • func (s *StmtExtendContext) EXTEND() antlr.TerminalNode
  • func (s *StmtExtendContext) Expr() IExprContext
  • func (s *StmtExtendContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtExtendContext) KeyValue(i int) IKeyValueContext
  • func (s *StmtExtendContext) L_CURLY() antlr.TerminalNode
  • func (s *StmtExtendContext) R_CURLY() antlr.TerminalNode
• type StmtForContext
  • func NewStmtForContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtForContext
  • func (s *StmtForContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtForContext) AllExpr() []IExprContext
  • func (s *StmtForContext) AllSEMICOLON() []antlr.TerminalNode
  • func (s *StmtForContext) COLON() antlr.TerminalNode
  • func (s *StmtForContext) CodeBlock() ICodeBlockContext
  • func (s *StmtForContext) Expr(i int) IExprContext
  • func (s *StmtForContext) FOR() antlr.TerminalNode
  • func (s *StmtForContext) GetCheckExpr() IExprContext
  • func (s *StmtForContext) GetExecBlock() ICodeBlockContext
  • func (s *StmtForContext) GetInitExpr() IExprContext
  • func (s *StmtForContext) GetLabel() antlr.Token
  • func (s *StmtForContext) GetNextExpr() IExprContext
  • func (s *StmtForContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtForContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtForContext) SEMICOLON(i int) antlr.TerminalNode
  • func (s *StmtForContext) SetCheckExpr(v IExprContext)
  • func (s *StmtForContext) SetExecBlock(v ICodeBlockContext)
  • func (s *StmtForContext) SetInitExpr(v IExprContext)
  • func (s *StmtForContext) SetLabel(v antlr.Token)
  • func (s *StmtForContext) SetNextExpr(v IExprContext)
• type StmtForEachContext
  • func NewStmtForEachContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtForEachContext
  • func (s *StmtForEachContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtForEachContext) AllExpr() []IExprContext
  • func (s *StmtForEachContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *StmtForEachContext) COLON() antlr.TerminalNode
  • func (s *StmtForEachContext) COMMA() antlr.TerminalNode
  • func (s *StmtForEachContext) CodeBlock() ICodeBlockContext
  • func (s *StmtForEachContext) Expr(i int) IExprContext
  • func (s *StmtForEachContext) FOR() antlr.TerminalNode
  • func (s *StmtForEachContext) GetBegin() IExprContext
  • func (s *StmtForEachContext) GetEnd() IExprContext
  • func (s *StmtForEachContext) GetExecBlock() ICodeBlockContext
  • func (s *StmtForEachContext) GetIdIndex() antlr.Token
  • func (s *StmtForEachContext) GetIdValue() antlr.Token
  • func (s *StmtForEachContext) GetLabel() antlr.Token
  • func (s *StmtForEachContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtForEachContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *StmtForEachContext) IN() antlr.TerminalNode
  • func (s *StmtForEachContext) RANGE_WITHOUT_END() antlr.TerminalNode
  • func (s *StmtForEachContext) RANGE_WITH_END() antlr.TerminalNode
  • func (s *StmtForEachContext) SetBegin(v IExprContext)
  • func (s *StmtForEachContext) SetEnd(v IExprContext)
  • func (s *StmtForEachContext) SetExecBlock(v ICodeBlockContext)
  • func (s *StmtForEachContext) SetIdIndex(v antlr.Token)
  • func (s *StmtForEachContext) SetIdValue(v antlr.Token)
  • func (s *StmtForEachContext) SetLabel(v antlr.Token)
• type StmtFuncCallContext
  • func NewStmtFuncCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtFuncCallContext
  • func (s *StmtFuncCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtFuncCallContext) CallStmt() ICallStmtContext
  • func (s *StmtFuncCallContext) GetRuleContext() antlr.RuleContext
• type StmtFuncDefineContext
  • func NewStmtFuncDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtFuncDefineContext
  • func (s *StmtFuncDefineContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtFuncDefineContext) AllCOMMA() []antlr.TerminalNode
  • func (s *StmtFuncDefineContext) AllIDENTIFIER() []antlr.TerminalNode
  • func (s *StmtFuncDefineContext) COMMA(i int) antlr.TerminalNode
  • func (s *StmtFuncDefineContext) CodeBlock() ICodeBlockContext
  • func (s *StmtFuncDefineContext) FUNC() antlr.TerminalNode
  • func (s *StmtFuncDefineContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtFuncDefineContext) IDENTIFIER(i int) antlr.TerminalNode
  • func (s *StmtFuncDefineContext) L_PAREN() antlr.TerminalNode
  • func (s *StmtFuncDefineContext) MORE_ARGS() antlr.TerminalNode
  • func (s *StmtFuncDefineContext) R_PAREN() antlr.TerminalNode
• type StmtIfContext
  • func NewStmtIfContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtIfContext
  • func (s *StmtIfContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtIfContext) AllCodeBlock() []ICodeBlockContext
  • func (s *StmtIfContext) AllELSE() []antlr.TerminalNode
  • func (s *StmtIfContext) AllIF() []antlr.TerminalNode
  • func (s *StmtIfContext) AllIfCondition() []IIfConditionContext
  • func (s *StmtIfContext) CodeBlock(i int) ICodeBlockContext
  • func (s *StmtIfContext) ELSE(i int) antlr.TerminalNode
  • func (s *StmtIfContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtIfContext) IF(i int) antlr.TerminalNode
  • func (s *StmtIfContext) IfCondition(i int) IIfConditionContext
• type StmtPostIncDecContext
  • func NewStmtPostIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtPostIncDecContext
  • func (s *StmtPostIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtPostIncDecContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtPostIncDecContext) PostIncDec() IPostIncDecContext
• type StmtPreIncDecContext
  • func NewStmtPreIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtPreIncDecContext
  • func (s *StmtPreIncDecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtPreIncDecContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtPreIncDecContext) PreIncDec() IPreIncDecContext
• type StmtReturnContext
  • func NewStmtReturnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtReturnContext
  • func (s *StmtReturnContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtReturnContext) Expr() IExprContext
  • func (s *StmtReturnContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtReturnContext) RETURN() antlr.TerminalNode
• type StmtReturnNoneContext
  • func NewStmtReturnNoneContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtReturnNoneContext
  • func (s *StmtReturnNoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtReturnNoneContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtReturnNoneContext) RETURN_NONE() antlr.TerminalNode
• type StmtSwitchContext
  • func NewStmtSwitchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtSwitchContext
  • func (s *StmtSwitchContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtSwitchContext) AllSwitchCase() []ISwitchCaseContext
  • func (s *StmtSwitchContext) Expr() IExprContext
  • func (s *StmtSwitchContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtSwitchContext) GetTestValue() IExprContext
  • func (s *StmtSwitchContext) L_CURLY() antlr.TerminalNode
  • func (s *StmtSwitchContext) R_CURLY() antlr.TerminalNode
  • func (s *StmtSwitchContext) SWITCH() antlr.TerminalNode
  • func (s *StmtSwitchContext) SetTestValue(v IExprContext)
  • func (s *StmtSwitchContext) SwitchCase(i int) ISwitchCaseContext
  • func (s *StmtSwitchContext) SwitchDefault() ISwitchDefaultContext
• type StmtTryContext
  • func NewStmtTryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtTryContext
  • func (s *StmtTryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtTryContext) AllCodeBlock() []ICodeBlockContext
  • func (s *StmtTryContext) CATCH() antlr.TerminalNode
  • func (s *StmtTryContext) CodeBlock(i int) ICodeBlockContext
  • func (s *StmtTryContext) FINALLY() antlr.TerminalNode
  • func (s *StmtTryContext) GetCatchBlock() ICodeBlockContext
  • func (s *StmtTryContext) GetExcName() antlr.Token
  • func (s *StmtTryContext) GetFinallyBlock() ICodeBlockContext
  • func (s *StmtTryContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtTryContext) GetTryBlock() ICodeBlockContext
  • func (s *StmtTryContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtTryContext) L_PAREN() antlr.TerminalNode
  • func (s *StmtTryContext) R_PAREN() antlr.TerminalNode
  • func (s *StmtTryContext) SetCatchBlock(v ICodeBlockContext)
  • func (s *StmtTryContext) SetExcName(v antlr.Token)
  • func (s *StmtTryContext) SetFinallyBlock(v ICodeBlockContext)
  • func (s *StmtTryContext) SetTryBlock(v ICodeBlockContext)
  • func (s *StmtTryContext) TRY() antlr.TerminalNode
• type StmtWhileContext
  • func NewStmtWhileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtWhileContext
  • func (s *StmtWhileContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StmtWhileContext) COLON() antlr.TerminalNode
  • func (s *StmtWhileContext) CodeBlock() ICodeBlockContext
  • func (s *StmtWhileContext) Expr() IExprContext
  • func (s *StmtWhileContext) GetCheckExpr() IExprContext
  • func (s *StmtWhileContext) GetExecBlock() ICodeBlockContext
  • func (s *StmtWhileContext) GetLabel() antlr.Token
  • func (s *StmtWhileContext) GetRuleContext() antlr.RuleContext
  • func (s *StmtWhileContext) IDENTIFIER() antlr.TerminalNode
  • func (s *StmtWhileContext) SetCheckExpr(v IExprContext)
  • func (s *StmtWhileContext) SetExecBlock(v ICodeBlockContext)
  • func (s *StmtWhileContext) SetLabel(v antlr.Token)
  • func (s *StmtWhileContext) WHILE() antlr.TerminalNode
• type StringLiteralContext
  • func NewEmptyStringLiteralContext() *StringLiteralContext
  • func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext
  • func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StringLiteralContext) GetParser() antlr.Parser
  • func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext
  • func (*StringLiteralContext) IsStringLiteralContext()
  • func (s *StringLiteralContext) RSTRING() antlr.TerminalNode
  • func (s *StringLiteralContext) STRING() antlr.TerminalNode
  • func (s *StringLiteralContext) TemplateString() ITemplateStringContext
  • func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SwitchCaseContext
  • func NewEmptySwitchCaseContext() *SwitchCaseContext
  • func NewSwitchCaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchCaseContext
  • func (s *SwitchCaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SwitchCaseContext) Block() IBlockContext
  • func (s *SwitchCaseContext) CASE() antlr.TerminalNode
  • func (s *SwitchCaseContext) COLON() antlr.TerminalNode
  • func (s *SwitchCaseContext) FALLTHROUGH() antlr.TerminalNode
  • func (s *SwitchCaseContext) GetParser() antlr.Parser
  • func (s *SwitchCaseContext) GetRuleContext() antlr.RuleContext
  • func (*SwitchCaseContext) IsSwitchCaseContext()
  • func (s *SwitchCaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *SwitchCaseContext) WhenCondition() IWhenConditionContext
• type SwitchDefaultContext
  • func NewEmptySwitchDefaultContext() *SwitchDefaultContext
  • func NewSwitchDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchDefaultContext
  • func (s *SwitchDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SwitchDefaultContext) Block() IBlockContext
  • func (s *SwitchDefaultContext) COLON() antlr.TerminalNode
  • func (s *SwitchDefaultContext) DEFAULT() antlr.TerminalNode
  • func (s *SwitchDefaultContext) GetParser() antlr.Parser
  • func (s *SwitchDefaultContext) GetRuleContext() antlr.RuleContext
  • func (*SwitchDefaultContext) IsSwitchDefaultContext()
  • func (s *SwitchDefaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SyntaxErrorInfo
  • func ParseFromString(filename, in string, shouldRecover bool) (ast.Node, []SyntaxErrorInfo)
  • func ParseReplFromString(in string, shouldRecover bool) (ast.Node, []SyntaxErrorInfo)
  • func (e *SyntaxErrorInfo) Error() string
  • func (e *SyntaxErrorInfo) String() string
• type TemplateStringContext
  • func NewEmptyTemplateStringContext() *TemplateStringContext
  • func NewTemplateStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringContext
  • func (s *TemplateStringContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TemplateStringContext) AllQUOTE() []antlr.TerminalNode
  • func (s *TemplateStringContext) AllTsItem() []ITsItemContext
  • func (s *TemplateStringContext) GetParser() antlr.Parser
  • func (s *TemplateStringContext) GetRuleContext() antlr.RuleContext
  • func (*TemplateStringContext) IsTemplateStringContext()
  • func (s *TemplateStringContext) QUOTE(i int) antlr.TerminalNode
  • func (s *TemplateStringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *TemplateStringContext) TsItem(i int) ITsItemContext
• type TsExprContext
  • func NewTsExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsExprContext
  • func (s *TsExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TsExprContext) Expr() IExprContext
  • func (s *TsExprContext) GetRuleContext() antlr.RuleContext
  • func (s *TsExprContext) R_CURLY() antlr.TerminalNode
  • func (s *TsExprContext) TS_EXPR_START() antlr.TerminalNode
• type TsIdentifierContext
  • func NewTsIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsIdentifierContext
  • func (s *TsIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TsIdentifierContext) GetRuleContext() antlr.RuleContext
  • func (s *TsIdentifierContext) TS_IDENTIFIER() antlr.TerminalNode
• type TsItemContext
  • func NewEmptyTsItemContext() *TsItemContext
  • func NewTsItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TsItemContext
  • func (s *TsItemContext) CopyAll(ctx *TsItemContext)
  • func (s *TsItemContext) GetParser() antlr.Parser
  • func (s *TsItemContext) GetRuleContext() antlr.RuleContext
  • func (*TsItemContext) IsTsItemContext()
  • func (s *TsItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type TsRawContext
  • func NewTsRawContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsRawContext
  • func (s *TsRawContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TsRawContext) GetRuleContext() antlr.RuleContext
  • func (s *TsRawContext) TS_RAW() antlr.TerminalNode
• type WhenConditionContext
  • func NewEmptyWhenConditionContext() *WhenConditionContext
  • func NewWhenConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenConditionContext
  • func (s *WhenConditionContext) CopyAll(ctx *WhenConditionContext)
  • func (s *WhenConditionContext) GetParser() antlr.Parser
  • func (s *WhenConditionContext) GetRuleContext() antlr.RuleContext
  • func (*WhenConditionContext) IsWhenConditionContext()
  • func (s *WhenConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type WhenConditionInListContext
  • func NewWhenConditionInListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionInListContext
  • func (s *WhenConditionInListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WhenConditionInListContext) AllCOMMA() []antlr.TerminalNode
  • func (s *WhenConditionInListContext) AllExpr() []IExprContext
  • func (s *WhenConditionInListContext) COMMA(i int) antlr.TerminalNode
  • func (s *WhenConditionInListContext) Expr(i int) IExprContext
  • func (s *WhenConditionInListContext) GetRuleContext() antlr.RuleContext
• type WhenConditionInRangeContext
  • func NewWhenConditionInRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionInRangeContext
  • func (s *WhenConditionInRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WhenConditionInRangeContext) AllExpr() []IExprContext
  • func (s *WhenConditionInRangeContext) Expr(i int) IExprContext
  • func (s *WhenConditionInRangeContext) GetLowerBound() IExprContext
  • func (s *WhenConditionInRangeContext) GetRuleContext() antlr.RuleContext
  • func (s *WhenConditionInRangeContext) GetUpperBound() IExprContext
  • func (s *WhenConditionInRangeContext) RANGE_WITHOUT_END() antlr.TerminalNode
  • func (s *WhenConditionInRangeContext) RANGE_WITH_END() antlr.TerminalNode
  • func (s *WhenConditionInRangeContext) SetLowerBound(v IExprContext)
  • func (s *WhenConditionInRangeContext) SetUpperBound(v IExprContext)
• type WhenConditionIsTypeContext
  • func NewWhenConditionIsTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionIsTypeContext
  • func (s *WhenConditionIsTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WhenConditionIsTypeContext) Expr() IExprContext
  • func (s *WhenConditionIsTypeContext) GetRuleContext() antlr.RuleContext
  • func (s *WhenConditionIsTypeContext) IS() antlr.TerminalNode
• type ZggBaseParser
• type ZggLexer
  • func NewZggLexer(input antlr.CharStream) *ZggLexer
• type ZggParser
  • func NewZggParser(input antlr.TokenStream) *ZggParser
  • func (p *ZggParser) Arguments() (localctx IArgumentsContext)
  • func (p *ZggParser) ArrayItem() (localctx IArrayItemContext)
  • func (p *ZggParser) AssignExpr() (localctx IAssignExprContext)
  • func (p *ZggParser) Block() (localctx IBlockContext)
  • func (p *ZggParser) CallStmt() (localctx ICallStmtContext)
  • func (p *ZggParser) CodeBlock() (localctx ICodeBlockContext)
  • func (p *ZggParser) Comparator() (localctx IComparatorContext)
  • func (p *ZggParser) Expr() (localctx IExprContext)
  • func (p *ZggParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *ZggParser) FuncArgument() (localctx IFuncArgumentContext)
  • func (p *ZggParser) IfCondition() (localctx IIfConditionContext)
  • func (p *ZggParser) Integer() (localctx IIntegerContext)
  • func (p *ZggParser) KeyValue() (localctx IKeyValueContext)
  • func (p *ZggParser) Literal() (localctx ILiteralContext)
  • func (p *ZggParser) Lval() (localctx ILvalContext)
  • func (p *ZggParser) Lval_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *ZggParser) MemberDef() (localctx IMemberDefContext)
  • func (p *ZggParser) Module() (localctx IModuleContext)
  • func (p *ZggParser) ObjItem() (localctx IObjItemContext)
  • func (p *ZggParser) PostIncDec() (localctx IPostIncDecContext)
  • func (p *ZggParser) PreIncDec() (localctx IPreIncDecContext)
  • func (p *ZggParser) ReplItem() (localctx IReplItemContext)
  • func (p *ZggParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool
  • func (p *ZggParser) Stmt() (localctx IStmtContext)
  • func (p *ZggParser) StringLiteral() (localctx IStringLiteralContext)
  • func (p *ZggParser) SwitchCase() (localctx ISwitchCaseContext)
  • func (p *ZggParser) SwitchDefault() (localctx ISwitchDefaultContext)
  • func (p *ZggParser) TemplateString() (localctx ITemplateStringContext)
  • func (p *ZggParser) TsItem() (localctx ITsItemContext)
  • func (p *ZggParser) WhenCondition() (localctx IWhenConditionContext)
• type ZggParserVisitor

Constants

const (
	ZggLexerTRUE              = 1
	ZggLexerFALSE             = 2
	ZggLexerFOR               = 3
	ZggLexerIN                = 4
	ZggLexerIF                = 5
	ZggLexerWHILE             = 6
	ZggLexerDO                = 7
	ZggLexerBREAK             = 8
	ZggLexerCONTINUE          = 9
	ZggLexerFUNC              = 10
	ZggLexerWHEN              = 11
	ZggLexerELSE              = 12
	ZggLexerNIL               = 13
	ZggLexerUNDEFINED         = 14
	ZggLexerRETURN_NONE       = 15
	ZggLexerRETURN            = 16
	ZggLexerEXPORT            = 17
	ZggLexerCLASS             = 18
	ZggLexerDEFER             = 19
	ZggLexerBLOCK_DEFER       = 20
	ZggLexerTHROW             = 21
	ZggLexerTRY               = 22
	ZggLexerCATCH             = 23
	ZggLexerFINALLY           = 24
	ZggLexerSTATIC            = 25
	ZggLexerASSERT            = 26
	ZggLexerEXTEND            = 27
	ZggLexerUSE_AT            = 28
	ZggLexerUSE               = 29
	ZggLexerSWITCH            = 30
	ZggLexerCASE              = 31
	ZggLexerFALLTHROUGH       = 32
	ZggLexerDEFAULT           = 33
	ZggLexerIS                = 34
	ZggLexerWS                = 35
	ZggLexerLINECOMMENT       = 36
	ZggLexerLINECOMMENT2      = 37
	ZggLexerBLOCKCOMMENT      = 38
	ZggLexerINT_ZERO          = 39
	ZggLexerINT_DEC           = 40
	ZggLexerINT_HEX           = 41
	ZggLexerINT_OCT           = 42
	ZggLexerINT_BIN           = 43
	ZggLexerBIGNUM            = 44
	ZggLexerFLOAT             = 45
	ZggLexerENUM              = 46
	ZggLexerSTRING            = 47
	ZggLexerRSTRING           = 48
	ZggLexerMORE_ARGS         = 49
	ZggLexerLEAD_TO           = 50
	ZggLexerARROW             = 51
	ZggLexerPOW               = 52
	ZggLexerPLUS_PLUS         = 53
	ZggLexerMINUS_MINUS       = 54
	ZggLexerEQUAL             = 55
	ZggLexerNOT_EQUAL         = 56
	ZggLexerGTEQ              = 57
	ZggLexerLTEQ              = 58
	ZggLexerLOCAL_ASSIGN      = 59
	ZggLexerPLUS_ASSIGN       = 60
	ZggLexerMINUS_ASSIGN      = 61
	ZggLexerTIMES_ASSIGN      = 62
	ZggLexerDIV_ASSIGN        = 63
	ZggLexerMOD_ASSIGN        = 64
	ZggLexerLOGIC_AND         = 65
	ZggLexerLOGIC_OR          = 66
	ZggLexerOPTIONAL_CALL     = 67
	ZggLexerOPTIONAL_ELSE     = 68
	ZggLexerBIT_AND           = 69
	ZggLexerBIT_OR            = 70
	ZggLexerBIT_NOT           = 71
	ZggLexerBIT_SHL           = 72
	ZggLexerBIT_SHR           = 73
	ZggLexerBIT_XOR           = 74
	ZggLexerBIT_AND_ASSIGN    = 75
	ZggLexerBIT_OR_ASSIGN     = 76
	ZggLexerBIT_SHL_ASSIGN    = 77
	ZggLexerBIT_SHR_ASSIGN    = 78
	ZggLexerBIT_XOR_ASSIGN    = 79
	ZggLexerRANGE_WITHOUT_END = 80
	ZggLexerRANGE_WITH_END    = 81
	ZggLexerDOT               = 82
	ZggLexerCOMMA             = 83
	ZggLexerSEMICOLON         = 84
	ZggLexerCOLON             = 85
	ZggLexerL_PAREN           = 86
	ZggLexerR_PAREN           = 87
	ZggLexerL_CURLY           = 88
	ZggLexerR_CURLY           = 89
	ZggLexerL_BRACKET         = 90
	ZggLexerR_BRACKET         = 91
	ZggLexerLOGIC_NOT         = 92
	ZggLexerQUESTION          = 93
	ZggLexerGT                = 94
	ZggLexerLT                = 95
	ZggLexerASSIGN            = 96
	ZggLexerPLUS              = 97
	ZggLexerMINUS             = 98
	ZggLexerTIMES             = 99
	ZggLexerDIV               = 100
	ZggLexerMOD               = 101
	ZggLexerSINGLE_AT         = 102
	ZggLexerDOUBLE_AT         = 103
	ZggLexerQUOTE             = 104
	ZggLexerIDENTIFIER        = 105
	ZggLexerTS_RAW            = 106
	ZggLexerTS_EXPR_START     = 107
	ZggLexerTS_IDENTIFIER     = 108
	ZggLexerStrExpr_WS        = 109
)

ZggLexer tokens.

const (
	ZggLexerTemplateString = iota + 1
	ZggLexerStrExpr
)

ZggLexer modes.

const (
	ZggParserEOF               = antlr.TokenEOF
	ZggParserTRUE              = 1
	ZggParserFALSE             = 2
	ZggParserFOR               = 3
	ZggParserIN                = 4
	ZggParserIF                = 5
	ZggParserWHILE             = 6
	ZggParserDO                = 7
	ZggParserBREAK             = 8
	ZggParserCONTINUE          = 9
	ZggParserFUNC              = 10
	ZggParserWHEN              = 11
	ZggParserELSE              = 12
	ZggParserNIL               = 13
	ZggParserUNDEFINED         = 14
	ZggParserRETURN_NONE       = 15
	ZggParserRETURN            = 16
	ZggParserEXPORT            = 17
	ZggParserCLASS             = 18
	ZggParserDEFER             = 19
	ZggParserBLOCK_DEFER       = 20
	ZggParserTHROW             = 21
	ZggParserTRY               = 22
	ZggParserCATCH             = 23
	ZggParserFINALLY           = 24
	ZggParserSTATIC            = 25
	ZggParserASSERT            = 26
	ZggParserEXTEND            = 27
	ZggParserUSE_AT            = 28
	ZggParserUSE               = 29
	ZggParserSWITCH            = 30
	ZggParserCASE              = 31
	ZggParserFALLTHROUGH       = 32
	ZggParserDEFAULT           = 33
	ZggParserIS                = 34
	ZggParserWS                = 35
	ZggParserLINECOMMENT       = 36
	ZggParserLINECOMMENT2      = 37
	ZggParserBLOCKCOMMENT      = 38
	ZggParserINT_ZERO          = 39
	ZggParserINT_DEC           = 40
	ZggParserINT_HEX           = 41
	ZggParserINT_OCT           = 42
	ZggParserINT_BIN           = 43
	ZggParserBIGNUM            = 44
	ZggParserFLOAT             = 45
	ZggParserENUM              = 46
	ZggParserSTRING            = 47
	ZggParserRSTRING           = 48
	ZggParserMORE_ARGS         = 49
	ZggParserLEAD_TO           = 50
	ZggParserARROW             = 51
	ZggParserPOW               = 52
	ZggParserPLUS_PLUS         = 53
	ZggParserMINUS_MINUS       = 54
	ZggParserEQUAL             = 55
	ZggParserNOT_EQUAL         = 56
	ZggParserGTEQ              = 57
	ZggParserLTEQ              = 58
	ZggParserLOCAL_ASSIGN      = 59
	ZggParserPLUS_ASSIGN       = 60
	ZggParserMINUS_ASSIGN      = 61
	ZggParserTIMES_ASSIGN      = 62
	ZggParserDIV_ASSIGN        = 63
	ZggParserMOD_ASSIGN        = 64
	ZggParserLOGIC_AND         = 65
	ZggParserLOGIC_OR          = 66
	ZggParserOPTIONAL_CALL     = 67
	ZggParserOPTIONAL_ELSE     = 68
	ZggParserBIT_AND           = 69
	ZggParserBIT_OR            = 70
	ZggParserBIT_NOT           = 71
	ZggParserBIT_SHL           = 72
	ZggParserBIT_SHR           = 73
	ZggParserBIT_XOR           = 74
	ZggParserBIT_AND_ASSIGN    = 75
	ZggParserBIT_OR_ASSIGN     = 76
	ZggParserBIT_SHL_ASSIGN    = 77
	ZggParserBIT_SHR_ASSIGN    = 78
	ZggParserBIT_XOR_ASSIGN    = 79
	ZggParserRANGE_WITHOUT_END = 80
	ZggParserRANGE_WITH_END    = 81
	ZggParserDOT               = 82
	ZggParserCOMMA             = 83
	ZggParserSEMICOLON         = 84
	ZggParserCOLON             = 85
	ZggParserL_PAREN           = 86
	ZggParserR_PAREN           = 87
	ZggParserL_CURLY           = 88
	ZggParserR_CURLY           = 89
	ZggParserL_BRACKET         = 90
	ZggParserR_BRACKET         = 91
	ZggParserLOGIC_NOT         = 92
	ZggParserQUESTION          = 93
	ZggParserGT                = 94
	ZggParserLT                = 95
	ZggParserASSIGN            = 96
	ZggParserPLUS              = 97
	ZggParserMINUS             = 98
	ZggParserTIMES             = 99
	ZggParserDIV               = 100
	ZggParserMOD               = 101
	ZggParserSINGLE_AT         = 102
	ZggParserDOUBLE_AT         = 103
	ZggParserQUOTE             = 104
	ZggParserIDENTIFIER        = 105
	ZggParserTS_RAW            = 106
	ZggParserTS_EXPR_START     = 107
	ZggParserTS_IDENTIFIER     = 108
	ZggParserStrExpr_WS        = 109
)

ZggParser tokens.

const (
	ZggParserRULE_replItem       = 0
	ZggParserRULE_module         = 1
	ZggParserRULE_block          = 2
	ZggParserRULE_codeBlock      = 3
	ZggParserRULE_stmt           = 4
	ZggParserRULE_ifCondition    = 5
	ZggParserRULE_memberDef      = 6
	ZggParserRULE_callStmt       = 7
	ZggParserRULE_switchCase     = 8
	ZggParserRULE_switchDefault  = 9
	ZggParserRULE_comparator     = 10
	ZggParserRULE_expr           = 11
	ZggParserRULE_whenCondition  = 12
	ZggParserRULE_arguments      = 13
	ZggParserRULE_funcArgument   = 14
	ZggParserRULE_assignExpr     = 15
	ZggParserRULE_preIncDec      = 16
	ZggParserRULE_postIncDec     = 17
	ZggParserRULE_lval           = 18
	ZggParserRULE_integer        = 19
	ZggParserRULE_literal        = 20
	ZggParserRULE_arrayItem      = 21
	ZggParserRULE_objItem        = 22
	ZggParserRULE_keyValue       = 23
	ZggParserRULE_stringLiteral  = 24
	ZggParserRULE_templateString = 25
	ZggParserRULE_tsItem         = 26
)

ZggParser rules.

Variables

var ZggLexerLexerStaticData struct {
	ChannelNames           []string
	ModeNames              []string
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

var ZggParserParserStaticData struct {
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

Functions

func GetModulePath

func GetModulePath(c *runtime.Context, name string) string

func InitEmptyArgumentsContext

func InitEmptyArgumentsContext(p *ArgumentsContext)

func InitEmptyArrayItemContext

func InitEmptyArrayItemContext(p *ArrayItemContext)

func InitEmptyAssignExprContext

func InitEmptyAssignExprContext(p *AssignExprContext)

func InitEmptyBlockContext

func InitEmptyBlockContext(p *BlockContext)

func InitEmptyCallStmtContext

func InitEmptyCallStmtContext(p *CallStmtContext)

func InitEmptyCodeBlockContext

func InitEmptyCodeBlockContext(p *CodeBlockContext)

func InitEmptyComparatorContext

func InitEmptyComparatorContext(p *ComparatorContext)

func InitEmptyExprContext

func InitEmptyExprContext(p *ExprContext)

func InitEmptyFuncArgumentContext

func InitEmptyFuncArgumentContext(p *FuncArgumentContext)

func InitEmptyIfConditionContext

func InitEmptyIfConditionContext(p *IfConditionContext)

func InitEmptyIntegerContext

func InitEmptyIntegerContext(p *IntegerContext)

func InitEmptyKeyValueContext

func InitEmptyKeyValueContext(p *KeyValueContext)

func InitEmptyLiteralContext

func InitEmptyLiteralContext(p *LiteralContext)

func InitEmptyLvalContext

func InitEmptyLvalContext(p *LvalContext)

func InitEmptyMemberDefContext

func InitEmptyMemberDefContext(p *MemberDefContext)

func InitEmptyModuleContext

func InitEmptyModuleContext(p *ModuleContext)

func InitEmptyObjItemContext

func InitEmptyObjItemContext(p *ObjItemContext)

func InitEmptyPostIncDecContext

func InitEmptyPostIncDecContext(p *PostIncDecContext)

func InitEmptyPreIncDecContext

func InitEmptyPreIncDecContext(p *PreIncDecContext)

func InitEmptyReplItemContext

func InitEmptyReplItemContext(p *ReplItemContext)

func InitEmptyStmtContext

func InitEmptyStmtContext(p *StmtContext)

func InitEmptyStringLiteralContext

func InitEmptyStringLiteralContext(p *StringLiteralContext)

func InitEmptySwitchCaseContext

func InitEmptySwitchCaseContext(p *SwitchCaseContext)

func InitEmptySwitchDefaultContext

func InitEmptySwitchDefaultContext(p *SwitchDefaultContext)

func InitEmptyTemplateStringContext

func InitEmptyTemplateStringContext(p *TemplateStringContext)

func InitEmptyTsItemContext

func InitEmptyTsItemContext(p *TsItemContext)

func InitEmptyWhenConditionContext

func InitEmptyWhenConditionContext(p *WhenConditionContext)

func SimpleImport

func SimpleImport(c *runtime.Context, name string, code string, importType string, reloadIfNewer bool) (modVal runtime.Value, thisTime int64, success bool)

func ZggLexerInit

func ZggLexerInit()

ZggLexerInit initializes any static state used to implement ZggLexer. By default the static state used to implement the lexer is lazily initialized during the first call to NewZggLexer(). You can call this function if you wish to initialize the static state ahead of time.

func ZggParserInit

func ZggParserInit()

ZggParserInit initializes any static state used to implement ZggParser. By default the static state used to implement the parser is lazily initialized during the first call to NewZggParser(). You can call this function if you wish to initialize the static state ahead of time.

Types

type ArgumentsContext

type ArgumentsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArgumentsContext

func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext

func NewEmptyArgumentsContext

func NewEmptyArgumentsContext() *ArgumentsContext

func (*ArgumentsContext) Accept

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

func (*ArgumentsContext) AllCOMMA

func (s *ArgumentsContext) AllCOMMA() []antlr.TerminalNode

func (*ArgumentsContext) AllFuncArgument

func (s *ArgumentsContext) AllFuncArgument() []IFuncArgumentContext

func (*ArgumentsContext) COMMA

func (s *ArgumentsContext) COMMA(i int) antlr.TerminalNode

func (*ArgumentsContext) FuncArgument

func (s *ArgumentsContext) FuncArgument(i int) IFuncArgumentContext

func (*ArgumentsContext) GetParser

func (s *ArgumentsContext) GetParser() antlr.Parser

func (*ArgumentsContext) GetRuleContext

func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext

func (*ArgumentsContext) IsArgumentsContext

func (*ArgumentsContext) IsArgumentsContext()

func (*ArgumentsContext) L_PAREN

func (s *ArgumentsContext) L_PAREN() antlr.TerminalNode

func (*ArgumentsContext) R_PAREN

func (s *ArgumentsContext) R_PAREN() antlr.TerminalNode

func (*ArgumentsContext) ToStringTree

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

type ArrayComprehensionContext

type ArrayComprehensionContext struct {
	LiteralContext
	// contains filtered or unexported fields
}

func NewArrayComprehensionContext

func NewArrayComprehensionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayComprehensionContext

func (*ArrayComprehensionContext) Accept

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

func (*ArrayComprehensionContext) AllExpr

func (s *ArrayComprehensionContext) AllExpr() []IExprContext

func (*ArrayComprehensionContext) AllIDENTIFIER

func (s *ArrayComprehensionContext) AllIDENTIFIER() []antlr.TerminalNode

func (*ArrayComprehensionContext) COMMA

func (s *ArrayComprehensionContext) COMMA() antlr.TerminalNode

func (*ArrayComprehensionContext) Expr

func (s *ArrayComprehensionContext) Expr(i int) IExprContext

func (*ArrayComprehensionContext) FOR

func (s *ArrayComprehensionContext) FOR() antlr.TerminalNode

func (*ArrayComprehensionContext) GetBegin

func (s *ArrayComprehensionContext) GetBegin() IExprContext

func (*ArrayComprehensionContext) GetEnd

func (s *ArrayComprehensionContext) GetEnd() IExprContext

func (*ArrayComprehensionContext) GetFilter

func (s *ArrayComprehensionContext) GetFilter() IExprContext

func (*ArrayComprehensionContext) GetIndexer

func (s *ArrayComprehensionContext) GetIndexer() antlr.Token

func (*ArrayComprehensionContext) GetItemExpr

func (s *ArrayComprehensionContext) GetItemExpr() IExprContext

func (*ArrayComprehensionContext) GetRuleContext

func (s *ArrayComprehensionContext) GetRuleContext() antlr.RuleContext

func (*ArrayComprehensionContext) GetValue

func (s *ArrayComprehensionContext) GetValue() antlr.Token

func (*ArrayComprehensionContext) IDENTIFIER

func (s *ArrayComprehensionContext) IDENTIFIER(i int) antlr.TerminalNode

func (*ArrayComprehensionContext) IF

func (s *ArrayComprehensionContext) IF() antlr.TerminalNode

func (*ArrayComprehensionContext) IN

func (s *ArrayComprehensionContext) IN() antlr.TerminalNode

func (*ArrayComprehensionContext) L_BRACKET

func (s *ArrayComprehensionContext) L_BRACKET() antlr.TerminalNode

func (*ArrayComprehensionContext) RANGE_WITHOUT_END

func (s *ArrayComprehensionContext) RANGE_WITHOUT_END() antlr.TerminalNode

func (*ArrayComprehensionContext) RANGE_WITH_END

func (s *ArrayComprehensionContext) RANGE_WITH_END() antlr.TerminalNode

func (*ArrayComprehensionContext) R_BRACKET

func (s *ArrayComprehensionContext) R_BRACKET() antlr.TerminalNode

func (*ArrayComprehensionContext) SetBegin

func (s *ArrayComprehensionContext) SetBegin(v IExprContext)

func (*ArrayComprehensionContext) SetEnd

func (s *ArrayComprehensionContext) SetEnd(v IExprContext)

func (*ArrayComprehensionContext) SetFilter

func (s *ArrayComprehensionContext) SetFilter(v IExprContext)

func (*ArrayComprehensionContext) SetIndexer

func (s *ArrayComprehensionContext) SetIndexer(v antlr.Token)

func (*ArrayComprehensionContext) SetItemExpr

func (s *ArrayComprehensionContext) SetItemExpr(v IExprContext)

func (*ArrayComprehensionContext) SetValue

func (s *ArrayComprehensionContext) SetValue(v antlr.Token)

type ArrayItemContext

type ArrayItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayItemContext

func NewArrayItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayItemContext

func NewEmptyArrayItemContext

func NewEmptyArrayItemContext() *ArrayItemContext

func (*ArrayItemContext) Accept

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

func (*ArrayItemContext) AllExpr

func (s *ArrayItemContext) AllExpr() []IExprContext

func (*ArrayItemContext) Expr

func (s *ArrayItemContext) Expr(i int) IExprContext

func (*ArrayItemContext) GetCondition

func (s *ArrayItemContext) GetCondition() IExprContext

func (*ArrayItemContext) GetParser

func (s *ArrayItemContext) GetParser() antlr.Parser

func (*ArrayItemContext) GetRuleContext

func (s *ArrayItemContext) GetRuleContext() antlr.RuleContext

func (*ArrayItemContext) IF

func (s *ArrayItemContext) IF() antlr.TerminalNode

func (*ArrayItemContext) IsArrayItemContext

func (*ArrayItemContext) IsArrayItemContext()

func (*ArrayItemContext) MORE_ARGS

func (s *ArrayItemContext) MORE_ARGS() antlr.TerminalNode

func (*ArrayItemContext) SetCondition

func (s *ArrayItemContext) SetCondition(v IExprContext)

func (*ArrayItemContext) ToStringTree

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

type AssignExistsContext

type AssignExistsContext struct {
	AssignExprContext
	// contains filtered or unexported fields
}

func NewAssignExistsContext

func NewAssignExistsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignExistsContext

func (*AssignExistsContext) ASSIGN

func (s *AssignExistsContext) ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) Accept

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

func (*AssignExistsContext) BIT_AND_ASSIGN

func (s *AssignExistsContext) BIT_AND_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) BIT_OR_ASSIGN

func (s *AssignExistsContext) BIT_OR_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) BIT_SHL_ASSIGN

func (s *AssignExistsContext) BIT_SHL_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) BIT_SHR_ASSIGN

func (s *AssignExistsContext) BIT_SHR_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) BIT_XOR_ASSIGN

func (s *AssignExistsContext) BIT_XOR_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) DIV_ASSIGN

func (s *AssignExistsContext) DIV_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) Expr

func (s *AssignExistsContext) Expr() IExprContext

func (*AssignExistsContext) GetOp

func (s *AssignExistsContext) GetOp() antlr.Token

func (*AssignExistsContext) GetRuleContext

func (s *AssignExistsContext) GetRuleContext() antlr.RuleContext

func (*AssignExistsContext) Lval

func (s *AssignExistsContext) Lval() ILvalContext

func (*AssignExistsContext) MINUS_ASSIGN

func (s *AssignExistsContext) MINUS_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) PLUS_ASSIGN

func (s *AssignExistsContext) PLUS_ASSIGN() antlr.TerminalNode

func (*AssignExistsContext) SetOp

func (s *AssignExistsContext) SetOp(v antlr.Token)

func (*AssignExistsContext) TIMES_ASSIGN

func (s *AssignExistsContext) TIMES_ASSIGN() antlr.TerminalNode

type AssignExprContext

type AssignExprContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAssignExprContext

func NewAssignExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignExprContext

func NewEmptyAssignExprContext

func NewEmptyAssignExprContext() *AssignExprContext

func (*AssignExprContext) CopyAll

func (s *AssignExprContext) CopyAll(ctx *AssignExprContext)

func (*AssignExprContext) GetParser

func (s *AssignExprContext) GetParser() antlr.Parser

func (*AssignExprContext) GetRuleContext

func (s *AssignExprContext) GetRuleContext() antlr.RuleContext

func (*AssignExprContext) IsAssignExprContext

func (*AssignExprContext) IsAssignExprContext()

func (*AssignExprContext) ToStringTree

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

type AssignNewContext

type AssignNewContext struct {
	AssignExprContext
}

func NewAssignNewContext

func NewAssignNewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewContext

func (*AssignNewContext) Accept

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

func (*AssignNewContext) Expr

func (s *AssignNewContext) Expr() IExprContext

func (*AssignNewContext) GetRuleContext

func (s *AssignNewContext) GetRuleContext() antlr.RuleContext

func (*AssignNewContext) IDENTIFIER

func (s *AssignNewContext) IDENTIFIER() antlr.TerminalNode

func (*AssignNewContext) LOCAL_ASSIGN

func (s *AssignNewContext) LOCAL_ASSIGN() antlr.TerminalNode

type AssignNewDeArrayContext

type AssignNewDeArrayContext struct {
	AssignExprContext
}

func NewAssignNewDeArrayContext

func NewAssignNewDeArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewDeArrayContext

func (*AssignNewDeArrayContext) Accept

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

func (*AssignNewDeArrayContext) AllCOMMA

func (s *AssignNewDeArrayContext) AllCOMMA() []antlr.TerminalNode

func (*AssignNewDeArrayContext) AllIDENTIFIER

func (s *AssignNewDeArrayContext) AllIDENTIFIER() []antlr.TerminalNode

func (*AssignNewDeArrayContext) COMMA

func (s *AssignNewDeArrayContext) COMMA(i int) antlr.TerminalNode

func (*AssignNewDeArrayContext) Expr

func (s *AssignNewDeArrayContext) Expr() IExprContext

func (*AssignNewDeArrayContext) GetRuleContext

func (s *AssignNewDeArrayContext) GetRuleContext() antlr.RuleContext

func (*AssignNewDeArrayContext) IDENTIFIER

func (s *AssignNewDeArrayContext) IDENTIFIER(i int) antlr.TerminalNode

func (*AssignNewDeArrayContext) LOCAL_ASSIGN

func (s *AssignNewDeArrayContext) LOCAL_ASSIGN() antlr.TerminalNode

func (*AssignNewDeArrayContext) L_BRACKET

func (s *AssignNewDeArrayContext) L_BRACKET() antlr.TerminalNode

func (*AssignNewDeArrayContext) MORE_ARGS

func (s *AssignNewDeArrayContext) MORE_ARGS() antlr.TerminalNode

func (*AssignNewDeArrayContext) R_BRACKET

func (s *AssignNewDeArrayContext) R_BRACKET() antlr.TerminalNode

type AssignNewDeObjectContext

type AssignNewDeObjectContext struct {
	AssignExprContext
}

func NewAssignNewDeObjectContext

func NewAssignNewDeObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewDeObjectContext

func (*AssignNewDeObjectContext) Accept

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

func (*AssignNewDeObjectContext) AllCOMMA

func (s *AssignNewDeObjectContext) AllCOMMA() []antlr.TerminalNode

func (*AssignNewDeObjectContext) AllIDENTIFIER

func (s *AssignNewDeObjectContext) AllIDENTIFIER() []antlr.TerminalNode

func (*AssignNewDeObjectContext) AllL_CURLY

func (s *AssignNewDeObjectContext) AllL_CURLY() []antlr.TerminalNode

func (*AssignNewDeObjectContext) COMMA

func (s *AssignNewDeObjectContext) COMMA(i int) antlr.TerminalNode

func (*AssignNewDeObjectContext) Expr

func (s *AssignNewDeObjectContext) Expr() IExprContext

func (*AssignNewDeObjectContext) GetRuleContext

func (s *AssignNewDeObjectContext) GetRuleContext() antlr.RuleContext

func (*AssignNewDeObjectContext) IDENTIFIER

func (s *AssignNewDeObjectContext) IDENTIFIER(i int) antlr.TerminalNode

func (*AssignNewDeObjectContext) LOCAL_ASSIGN

func (s *AssignNewDeObjectContext) LOCAL_ASSIGN() antlr.TerminalNode

func (*AssignNewDeObjectContext) L_CURLY

func (s *AssignNewDeObjectContext) L_CURLY(i int) antlr.TerminalNode

type AssignNewLocalContext

type AssignNewLocalContext struct {
	AssignExprContext
}

func NewAssignNewLocalContext

func NewAssignNewLocalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignNewLocalContext

func (*AssignNewLocalContext) Accept

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

func (*AssignNewLocalContext) Expr

func (s *AssignNewLocalContext) Expr() IExprContext

func (*AssignNewLocalContext) GetRuleContext

func (s *AssignNewLocalContext) GetRuleContext() antlr.RuleContext

func (*AssignNewLocalContext) LOCAL_ASSIGN

func (s *AssignNewLocalContext) LOCAL_ASSIGN() antlr.TerminalNode

func (*AssignNewLocalContext) MORE_ARGS

func (s *AssignNewLocalContext) MORE_ARGS() antlr.TerminalNode

type BaseZggParserVisitor

type BaseZggParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseZggParserVisitor) VisitArguments

func (v *BaseZggParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}

func (*BaseZggParserVisitor) VisitArrayComprehension

func (v *BaseZggParserVisitor) VisitArrayComprehension(ctx *ArrayComprehensionContext) interface{}

func (*BaseZggParserVisitor) VisitArrayItem

func (v *BaseZggParserVisitor) VisitArrayItem(ctx *ArrayItemContext) interface{}

func (*BaseZggParserVisitor) VisitAssignExists

func (v *BaseZggParserVisitor) VisitAssignExists(ctx *AssignExistsContext) interface{}

func (*BaseZggParserVisitor) VisitAssignNew

func (v *BaseZggParserVisitor) VisitAssignNew(ctx *AssignNewContext) interface{}

func (*BaseZggParserVisitor) VisitAssignNewDeArray

func (v *BaseZggParserVisitor) VisitAssignNewDeArray(ctx *AssignNewDeArrayContext) interface{}

func (*BaseZggParserVisitor) VisitAssignNewDeObject

func (v *BaseZggParserVisitor) VisitAssignNewDeObject(ctx *AssignNewDeObjectContext) interface{}

func (*BaseZggParserVisitor) VisitAssignNewLocal

func (v *BaseZggParserVisitor) VisitAssignNewLocal(ctx *AssignNewLocalContext) interface{}

func (*BaseZggParserVisitor) VisitBlock

func (v *BaseZggParserVisitor) VisitBlock(ctx *BlockContext) interface{}

func (*BaseZggParserVisitor) VisitCallStmt

func (v *BaseZggParserVisitor) VisitCallStmt(ctx *CallStmtContext) interface{}

func (*BaseZggParserVisitor) VisitCodeBlock

func (v *BaseZggParserVisitor) VisitCodeBlock(ctx *CodeBlockContext) interface{}

func (*BaseZggParserVisitor) VisitComparator

func (v *BaseZggParserVisitor) VisitComparator(ctx *ComparatorContext) interface{}

func (*BaseZggParserVisitor) VisitExprAssertError

func (v *BaseZggParserVisitor) VisitExprAssertError(ctx *ExprAssertErrorContext) interface{}

func (*BaseZggParserVisitor) VisitExprAssign

func (v *BaseZggParserVisitor) VisitExprAssign(ctx *ExprAssignContext) interface{}

func (*BaseZggParserVisitor) VisitExprBitAnd

func (v *BaseZggParserVisitor) VisitExprBitAnd(ctx *ExprBitAndContext) interface{}

func (*BaseZggParserVisitor) VisitExprBitNot

func (v *BaseZggParserVisitor) VisitExprBitNot(ctx *ExprBitNotContext) interface{}

func (*BaseZggParserVisitor) VisitExprBitOr

func (v *BaseZggParserVisitor) VisitExprBitOr(ctx *ExprBitOrContext) interface{}

func (*BaseZggParserVisitor) VisitExprBitShift

func (v *BaseZggParserVisitor) VisitExprBitShift(ctx *ExprBitShiftContext) interface{}

func (*BaseZggParserVisitor) VisitExprBitXor

func (v *BaseZggParserVisitor) VisitExprBitXor(ctx *ExprBitXorContext) interface{}

func (*BaseZggParserVisitor) VisitExprByField

func (v *BaseZggParserVisitor) VisitExprByField(ctx *ExprByFieldContext) interface{}

func (*BaseZggParserVisitor) VisitExprByIndex

func (v *BaseZggParserVisitor) VisitExprByIndex(ctx *ExprByIndexContext) interface{}

func (*BaseZggParserVisitor) VisitExprBySlice

func (v *BaseZggParserVisitor) VisitExprBySlice(ctx *ExprBySliceContext) interface{}

func (*BaseZggParserVisitor) VisitExprCall

func (v *BaseZggParserVisitor) VisitExprCall(ctx *ExprCallContext) interface{}

func (*BaseZggParserVisitor) VisitExprCompare

func (v *BaseZggParserVisitor) VisitExprCompare(ctx *ExprCompareContext) interface{}

func (*BaseZggParserVisitor) VisitExprFallback

func (v *BaseZggParserVisitor) VisitExprFallback(ctx *ExprFallbackContext) interface{}

func (*BaseZggParserVisitor) VisitExprIdentifier

func (v *BaseZggParserVisitor) VisitExprIdentifier(ctx *ExprIdentifierContext) interface{}

func (*BaseZggParserVisitor) VisitExprInContainer

func (v *BaseZggParserVisitor) VisitExprInContainer(ctx *ExprInContainerContext) interface{}

func (*BaseZggParserVisitor) VisitExprInRange

func (v *BaseZggParserVisitor) VisitExprInRange(ctx *ExprInRangeContext) interface{}

func (*BaseZggParserVisitor) VisitExprIsType

func (v *BaseZggParserVisitor) VisitExprIsType(ctx *ExprIsTypeContext) interface{}

func (*BaseZggParserVisitor) VisitExprItByField

func (v *BaseZggParserVisitor) VisitExprItByField(ctx *ExprItByFieldContext) interface{}

func (*BaseZggParserVisitor) VisitExprLiteral

func (v *BaseZggParserVisitor) VisitExprLiteral(ctx *ExprLiteralContext) interface{}

func (*BaseZggParserVisitor) VisitExprLogicAnd

func (v *BaseZggParserVisitor) VisitExprLogicAnd(ctx *ExprLogicAndContext) interface{}

func (*BaseZggParserVisitor) VisitExprLogicNot

func (v *BaseZggParserVisitor) VisitExprLogicNot(ctx *ExprLogicNotContext) interface{}

func (*BaseZggParserVisitor) VisitExprLogicOr

func (v *BaseZggParserVisitor) VisitExprLogicOr(ctx *ExprLogicOrContext) interface{}

func (*BaseZggParserVisitor) VisitExprNegative

func (v *BaseZggParserVisitor) VisitExprNegative(ctx *ExprNegativeContext) interface{}

func (*BaseZggParserVisitor) VisitExprPlusMinus

func (v *BaseZggParserVisitor) VisitExprPlusMinus(ctx *ExprPlusMinusContext) interface{}

func (*BaseZggParserVisitor) VisitExprPostIncDec

func (v *BaseZggParserVisitor) VisitExprPostIncDec(ctx *ExprPostIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitExprPow

func (v *BaseZggParserVisitor) VisitExprPow(ctx *ExprPowContext) interface{}

func (*BaseZggParserVisitor) VisitExprPreIncDec

func (v *BaseZggParserVisitor) VisitExprPreIncDec(ctx *ExprPreIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitExprQuestion

func (v *BaseZggParserVisitor) VisitExprQuestion(ctx *ExprQuestionContext) interface{}

func (*BaseZggParserVisitor) VisitExprShortImport

func (v *BaseZggParserVisitor) VisitExprShortImport(ctx *ExprShortImportContext) interface{}

func (*BaseZggParserVisitor) VisitExprSub

func (v *BaseZggParserVisitor) VisitExprSub(ctx *ExprSubContext) interface{}

func (*BaseZggParserVisitor) VisitExprTimesDivMod

func (v *BaseZggParserVisitor) VisitExprTimesDivMod(ctx *ExprTimesDivModContext) interface{}

func (*BaseZggParserVisitor) VisitExprUseBlock

func (v *BaseZggParserVisitor) VisitExprUseBlock(ctx *ExprUseBlockContext) interface{}

func (*BaseZggParserVisitor) VisitExprUseCloser

func (v *BaseZggParserVisitor) VisitExprUseCloser(ctx *ExprUseCloserContext) interface{}

func (*BaseZggParserVisitor) VisitExprUseMethod

func (v *BaseZggParserVisitor) VisitExprUseMethod(ctx *ExprUseMethodContext) interface{}

func (*BaseZggParserVisitor) VisitExprWhen

func (v *BaseZggParserVisitor) VisitExprWhen(ctx *ExprWhenContext) interface{}

func (*BaseZggParserVisitor) VisitExprWhenValue

func (v *BaseZggParserVisitor) VisitExprWhenValue(ctx *ExprWhenValueContext) interface{}

func (*BaseZggParserVisitor) VisitFuncArgument

func (v *BaseZggParserVisitor) VisitFuncArgument(ctx *FuncArgumentContext) interface{}

func (*BaseZggParserVisitor) VisitIfCondition

func (v *BaseZggParserVisitor) VisitIfCondition(ctx *IfConditionContext) interface{}

func (*BaseZggParserVisitor) VisitIntegerBin

func (v *BaseZggParserVisitor) VisitIntegerBin(ctx *IntegerBinContext) interface{}

func (*BaseZggParserVisitor) VisitIntegerDec

func (v *BaseZggParserVisitor) VisitIntegerDec(ctx *IntegerDecContext) interface{}

func (*BaseZggParserVisitor) VisitIntegerHex

func (v *BaseZggParserVisitor) VisitIntegerHex(ctx *IntegerHexContext) interface{}

func (*BaseZggParserVisitor) VisitIntegerOct

func (v *BaseZggParserVisitor) VisitIntegerOct(ctx *IntegerOctContext) interface{}

func (*BaseZggParserVisitor) VisitIntegerZero

func (v *BaseZggParserVisitor) VisitIntegerZero(ctx *IntegerZeroContext) interface{}

func (*BaseZggParserVisitor) VisitKVExprKey

func (v *BaseZggParserVisitor) VisitKVExprKey(ctx *KVExprKeyContext) interface{}

func (*BaseZggParserVisitor) VisitKVExprOnly

func (v *BaseZggParserVisitor) VisitKVExprOnly(ctx *KVExprOnlyContext) interface{}

func (*BaseZggParserVisitor) VisitKVIdKey

func (v *BaseZggParserVisitor) VisitKVIdKey(ctx *KVIdKeyContext) interface{}

func (*BaseZggParserVisitor) VisitKVIdOnly

func (v *BaseZggParserVisitor) VisitKVIdOnly(ctx *KVIdOnlyContext) interface{}

func (*BaseZggParserVisitor) VisitKVKeyFunc

func (v *BaseZggParserVisitor) VisitKVKeyFunc(ctx *KVKeyFuncContext) interface{}

func (*BaseZggParserVisitor) VisitKVStrKey

func (v *BaseZggParserVisitor) VisitKVStrKey(ctx *KVStrKeyContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralArray

func (v *BaseZggParserVisitor) VisitLiteralArray(ctx *LiteralArrayContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralBigNum

func (v *BaseZggParserVisitor) VisitLiteralBigNum(ctx *LiteralBigNumContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralBool

func (v *BaseZggParserVisitor) VisitLiteralBool(ctx *LiteralBoolContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralENum

func (v *BaseZggParserVisitor) VisitLiteralENum(ctx *LiteralENumContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralFloat

func (v *BaseZggParserVisitor) VisitLiteralFloat(ctx *LiteralFloatContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralFunc

func (v *BaseZggParserVisitor) VisitLiteralFunc(ctx *LiteralFuncContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralInteger

func (v *BaseZggParserVisitor) VisitLiteralInteger(ctx *LiteralIntegerContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralLambdaBlock

func (v *BaseZggParserVisitor) VisitLiteralLambdaBlock(ctx *LiteralLambdaBlockContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralLambdaExpr

func (v *BaseZggParserVisitor) VisitLiteralLambdaExpr(ctx *LiteralLambdaExprContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralNil

func (v *BaseZggParserVisitor) VisitLiteralNil(ctx *LiteralNilContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralObject

func (v *BaseZggParserVisitor) VisitLiteralObject(ctx *LiteralObjectContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralString

func (v *BaseZggParserVisitor) VisitLiteralString(ctx *LiteralStringContext) interface{}

func (*BaseZggParserVisitor) VisitLiteralUndefined

func (v *BaseZggParserVisitor) VisitLiteralUndefined(ctx *LiteralUndefinedContext) interface{}

func (*BaseZggParserVisitor) VisitLvalByField

func (v *BaseZggParserVisitor) VisitLvalByField(ctx *LvalByFieldContext) interface{}

func (*BaseZggParserVisitor) VisitLvalById

func (v *BaseZggParserVisitor) VisitLvalById(ctx *LvalByIdContext) interface{}

func (*BaseZggParserVisitor) VisitLvalByIndex

func (v *BaseZggParserVisitor) VisitLvalByIndex(ctx *LvalByIndexContext) interface{}

func (*BaseZggParserVisitor) VisitLvalItByField

func (v *BaseZggParserVisitor) VisitLvalItByField(ctx *LvalItByFieldContext) interface{}

func (*BaseZggParserVisitor) VisitMemberDef

func (v *BaseZggParserVisitor) VisitMemberDef(ctx *MemberDefContext) interface{}

func (*BaseZggParserVisitor) VisitModule

func (v *BaseZggParserVisitor) VisitModule(ctx *ModuleContext) interface{}

func (*BaseZggParserVisitor) VisitObjItemExpanded

func (v *BaseZggParserVisitor) VisitObjItemExpanded(ctx *ObjItemExpandedContext) interface{}

func (*BaseZggParserVisitor) VisitObjItemKV

func (v *BaseZggParserVisitor) VisitObjItemKV(ctx *ObjItemKVContext) interface{}

func (*BaseZggParserVisitor) VisitObjectComprehension

func (v *BaseZggParserVisitor) VisitObjectComprehension(ctx *ObjectComprehensionContext) interface{}

func (*BaseZggParserVisitor) VisitPostIncDec

func (v *BaseZggParserVisitor) VisitPostIncDec(ctx *PostIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitPreIncDec

func (v *BaseZggParserVisitor) VisitPreIncDec(ctx *PreIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitReplBlock

func (v *BaseZggParserVisitor) VisitReplBlock(ctx *ReplBlockContext) interface{}

func (*BaseZggParserVisitor) VisitReplExpr

func (v *BaseZggParserVisitor) VisitReplExpr(ctx *ReplExprContext) interface{}

func (*BaseZggParserVisitor) VisitStmtAssert

func (v *BaseZggParserVisitor) VisitStmtAssert(ctx *StmtAssertContext) interface{}

func (*BaseZggParserVisitor) VisitStmtAssign

func (v *BaseZggParserVisitor) VisitStmtAssign(ctx *StmtAssignContext) interface{}

func (*BaseZggParserVisitor) VisitStmtBlock

func (v *BaseZggParserVisitor) VisitStmtBlock(ctx *StmtBlockContext) interface{}

func (*BaseZggParserVisitor) VisitStmtBreak

func (v *BaseZggParserVisitor) VisitStmtBreak(ctx *StmtBreakContext) interface{}

func (*BaseZggParserVisitor) VisitStmtClassDefine

func (v *BaseZggParserVisitor) VisitStmtClassDefine(ctx *StmtClassDefineContext) interface{}

func (*BaseZggParserVisitor) VisitStmtContinue

func (v *BaseZggParserVisitor) VisitStmtContinue(ctx *StmtContinueContext) interface{}

func (*BaseZggParserVisitor) VisitStmtDefer

func (v *BaseZggParserVisitor) VisitStmtDefer(ctx *StmtDeferContext) interface{}

func (*BaseZggParserVisitor) VisitStmtDeferBlock

func (v *BaseZggParserVisitor) VisitStmtDeferBlock(ctx *StmtDeferBlockContext) interface{}

func (*BaseZggParserVisitor) VisitStmtDoWhile

func (v *BaseZggParserVisitor) VisitStmtDoWhile(ctx *StmtDoWhileContext) interface{}

func (*BaseZggParserVisitor) VisitStmtExportExpr

func (v *BaseZggParserVisitor) VisitStmtExportExpr(ctx *StmtExportExprContext) interface{}

func (*BaseZggParserVisitor) VisitStmtExportFuncDefine

func (v *BaseZggParserVisitor) VisitStmtExportFuncDefine(ctx *StmtExportFuncDefineContext) interface{}

func (*BaseZggParserVisitor) VisitStmtExportIdentifier

func (v *BaseZggParserVisitor) VisitStmtExportIdentifier(ctx *StmtExportIdentifierContext) interface{}

func (*BaseZggParserVisitor) VisitStmtExtend

func (v *BaseZggParserVisitor) VisitStmtExtend(ctx *StmtExtendContext) interface{}

func (*BaseZggParserVisitor) VisitStmtFor

func (v *BaseZggParserVisitor) VisitStmtFor(ctx *StmtForContext) interface{}

func (*BaseZggParserVisitor) VisitStmtForEach

func (v *BaseZggParserVisitor) VisitStmtForEach(ctx *StmtForEachContext) interface{}

func (*BaseZggParserVisitor) VisitStmtFuncCall

func (v *BaseZggParserVisitor) VisitStmtFuncCall(ctx *StmtFuncCallContext) interface{}

func (*BaseZggParserVisitor) VisitStmtFuncDefine

func (v *BaseZggParserVisitor) VisitStmtFuncDefine(ctx *StmtFuncDefineContext) interface{}

func (*BaseZggParserVisitor) VisitStmtIf

func (v *BaseZggParserVisitor) VisitStmtIf(ctx *StmtIfContext) interface{}

func (*BaseZggParserVisitor) VisitStmtPostIncDec

func (v *BaseZggParserVisitor) VisitStmtPostIncDec(ctx *StmtPostIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitStmtPreIncDec

func (v *BaseZggParserVisitor) VisitStmtPreIncDec(ctx *StmtPreIncDecContext) interface{}

func (*BaseZggParserVisitor) VisitStmtReturn

func (v *BaseZggParserVisitor) VisitStmtReturn(ctx *StmtReturnContext) interface{}

func (*BaseZggParserVisitor) VisitStmtReturnNone

func (v *BaseZggParserVisitor) VisitStmtReturnNone(ctx *StmtReturnNoneContext) interface{}

func (*BaseZggParserVisitor) VisitStmtSwitch

func (v *BaseZggParserVisitor) VisitStmtSwitch(ctx *StmtSwitchContext) interface{}

func (*BaseZggParserVisitor) VisitStmtTry

func (v *BaseZggParserVisitor) VisitStmtTry(ctx *StmtTryContext) interface{}

func (*BaseZggParserVisitor) VisitStmtWhile

func (v *BaseZggParserVisitor) VisitStmtWhile(ctx *StmtWhileContext) interface{}

func (*BaseZggParserVisitor) VisitStringLiteral

func (v *BaseZggParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

func (*BaseZggParserVisitor) VisitSwitchCase

func (v *BaseZggParserVisitor) VisitSwitchCase(ctx *SwitchCaseContext) interface{}

func (*BaseZggParserVisitor) VisitSwitchDefault

func (v *BaseZggParserVisitor) VisitSwitchDefault(ctx *SwitchDefaultContext) interface{}

func (*BaseZggParserVisitor) VisitTemplateString

func (v *BaseZggParserVisitor) VisitTemplateString(ctx *TemplateStringContext) interface{}

func (*BaseZggParserVisitor) VisitTsExpr

func (v *BaseZggParserVisitor) VisitTsExpr(ctx *TsExprContext) interface{}

func (*BaseZggParserVisitor) VisitTsIdentifier

func (v *BaseZggParserVisitor) VisitTsIdentifier(ctx *TsIdentifierContext) interface{}

func (*BaseZggParserVisitor) VisitTsRaw

func (v *BaseZggParserVisitor) VisitTsRaw(ctx *TsRawContext) interface{}

func (*BaseZggParserVisitor) VisitWhenConditionInList

func (v *BaseZggParserVisitor) VisitWhenConditionInList(ctx *WhenConditionInListContext) interface{}

func (*BaseZggParserVisitor) VisitWhenConditionInRange

func (v *BaseZggParserVisitor) VisitWhenConditionInRange(ctx *WhenConditionInRangeContext) interface{}

func (*BaseZggParserVisitor) VisitWhenConditionIsType

func (v *BaseZggParserVisitor) VisitWhenConditionIsType(ctx *WhenConditionIsTypeContext) interface{}

type BlockContext

type BlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBlockContext

func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext

func NewEmptyBlockContext

func NewEmptyBlockContext() *BlockContext

func (*BlockContext) Accept

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

func (*BlockContext) AllSEMICOLON

func (s *BlockContext) AllSEMICOLON() []antlr.TerminalNode

func (*BlockContext) AllStmt

func (s *BlockContext) AllStmt() []IStmtContext

func (*BlockContext) GetParser

func (s *BlockContext) GetParser() antlr.Parser

func (*BlockContext) GetRuleContext

func (s *BlockContext) GetRuleContext() antlr.RuleContext

func (*BlockContext) IsBlockContext

func (*BlockContext) IsBlockContext()

func (*BlockContext) SEMICOLON

func (s *BlockContext) SEMICOLON(i int) antlr.TerminalNode

func (*BlockContext) Stmt

func (s *BlockContext) Stmt(i int) IStmtContext

func (*BlockContext) ToStringTree

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

type CallStmtContext

type CallStmtContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCallStmtContext

func NewCallStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallStmtContext

func NewEmptyCallStmtContext

func NewEmptyCallStmtContext() *CallStmtContext

func (*CallStmtContext) Accept

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

func (*CallStmtContext) Arguments

func (s *CallStmtContext) Arguments() IArgumentsContext

func (*CallStmtContext) CodeBlock

func (s *CallStmtContext) CodeBlock() ICodeBlockContext

func (*CallStmtContext) Expr

func (s *CallStmtContext) Expr() IExprContext

func (*CallStmtContext) GetParser

func (s *CallStmtContext) GetParser() antlr.Parser

func (*CallStmtContext) GetRuleContext

func (s *CallStmtContext) GetRuleContext() antlr.RuleContext

func (*CallStmtContext) IsCallStmtContext

func (*CallStmtContext) IsCallStmtContext()

func (*CallStmtContext) OPTIONAL_CALL

func (s *CallStmtContext) OPTIONAL_CALL() antlr.TerminalNode

func (*CallStmtContext) OPTIONAL_ELSE

func (s *CallStmtContext) OPTIONAL_ELSE() antlr.TerminalNode

func (*CallStmtContext) ToStringTree

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

type CodeBlockContext

type CodeBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCodeBlockContext

func NewCodeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CodeBlockContext

func NewEmptyCodeBlockContext

func NewEmptyCodeBlockContext() *CodeBlockContext

func (*CodeBlockContext) Accept

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

func (*CodeBlockContext) Block

func (s *CodeBlockContext) Block() IBlockContext

func (*CodeBlockContext) GetParser

func (s *CodeBlockContext) GetParser() antlr.Parser

func (*CodeBlockContext) GetRuleContext

func (s *CodeBlockContext) GetRuleContext() antlr.RuleContext

func (*CodeBlockContext) IsCodeBlockContext

func (*CodeBlockContext) IsCodeBlockContext()

func (*CodeBlockContext) L_CURLY

func (s *CodeBlockContext) L_CURLY() antlr.TerminalNode

func (*CodeBlockContext) R_CURLY

func (s *CodeBlockContext) R_CURLY() antlr.TerminalNode

func (*CodeBlockContext) ToStringTree

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

type ComparatorContext

type ComparatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewComparatorContext

func NewComparatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparatorContext

func NewEmptyComparatorContext

func NewEmptyComparatorContext() *ComparatorContext

func (*ComparatorContext) Accept

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

func (*ComparatorContext) EQUAL

func (s *ComparatorContext) EQUAL() antlr.TerminalNode

func (*ComparatorContext) GT

func (s *ComparatorContext) GT() antlr.TerminalNode

func (*ComparatorContext) GTEQ

func (s *ComparatorContext) GTEQ() antlr.TerminalNode

func (*ComparatorContext) GetParser

func (s *ComparatorContext) GetParser() antlr.Parser

func (*ComparatorContext) GetRuleContext

func (s *ComparatorContext) GetRuleContext() antlr.RuleContext

func (*ComparatorContext) IsComparatorContext

func (*ComparatorContext) IsComparatorContext()

func (*ComparatorContext) LT

func (s *ComparatorContext) LT() antlr.TerminalNode

func (*ComparatorContext) LTEQ

func (s *ComparatorContext) LTEQ() antlr.TerminalNode

func (*ComparatorContext) NOT_EQUAL

func (s *ComparatorContext) NOT_EQUAL() antlr.TerminalNode

func (*ComparatorContext) ToStringTree

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

type ExprAssertErrorContext

type ExprAssertErrorContext struct {
	ExprContext
}

func NewExprAssertErrorContext

func NewExprAssertErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAssertErrorContext

func (*ExprAssertErrorContext) Accept

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

func (*ExprAssertErrorContext) Expr

func (s *ExprAssertErrorContext) Expr() IExprContext

func (*ExprAssertErrorContext) GetRuleContext

func (s *ExprAssertErrorContext) GetRuleContext() antlr.RuleContext

func (*ExprAssertErrorContext) LOGIC_NOT

func (s *ExprAssertErrorContext) LOGIC_NOT() antlr.TerminalNode

type ExprAssignContext

type ExprAssignContext struct {
	ExprContext
}

func NewExprAssignContext

func NewExprAssignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAssignContext

func (*ExprAssignContext) Accept

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

func (*ExprAssignContext) AssignExpr

func (s *ExprAssignContext) AssignExpr() IAssignExprContext

func (*ExprAssignContext) GetRuleContext

func (s *ExprAssignContext) GetRuleContext() antlr.RuleContext

type ExprBitAndContext

type ExprBitAndContext struct {
	ExprContext
}

func NewExprBitAndContext

func NewExprBitAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitAndContext

func (*ExprBitAndContext) Accept

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

func (*ExprBitAndContext) AllExpr

func (s *ExprBitAndContext) AllExpr() []IExprContext

func (*ExprBitAndContext) BIT_AND

func (s *ExprBitAndContext) BIT_AND() antlr.TerminalNode

func (*ExprBitAndContext) Expr

func (s *ExprBitAndContext) Expr(i int) IExprContext

func (*ExprBitAndContext) GetRuleContext

func (s *ExprBitAndContext) GetRuleContext() antlr.RuleContext

type ExprBitNotContext

type ExprBitNotContext struct {
	ExprContext
}

func NewExprBitNotContext

func NewExprBitNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitNotContext

func (*ExprBitNotContext) Accept

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

func (*ExprBitNotContext) BIT_NOT

func (s *ExprBitNotContext) BIT_NOT() antlr.TerminalNode

func (*ExprBitNotContext) Expr

func (s *ExprBitNotContext) Expr() IExprContext

func (*ExprBitNotContext) GetRuleContext

func (s *ExprBitNotContext) GetRuleContext() antlr.RuleContext

type ExprBitOrContext

type ExprBitOrContext struct {
	ExprContext
}

func NewExprBitOrContext

func NewExprBitOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitOrContext

func (*ExprBitOrContext) Accept

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

func (*ExprBitOrContext) AllExpr

func (s *ExprBitOrContext) AllExpr() []IExprContext

func (*ExprBitOrContext) BIT_OR

func (s *ExprBitOrContext) BIT_OR() antlr.TerminalNode

func (*ExprBitOrContext) Expr

func (s *ExprBitOrContext) Expr(i int) IExprContext

func (*ExprBitOrContext) GetRuleContext

func (s *ExprBitOrContext) GetRuleContext() antlr.RuleContext

type ExprBitShiftContext

type ExprBitShiftContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprBitShiftContext

func NewExprBitShiftContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitShiftContext

func (*ExprBitShiftContext) Accept

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

func (*ExprBitShiftContext) AllExpr

func (s *ExprBitShiftContext) AllExpr() []IExprContext

func (*ExprBitShiftContext) BIT_SHL

func (s *ExprBitShiftContext) BIT_SHL() antlr.TerminalNode

func (*ExprBitShiftContext) BIT_SHR

func (s *ExprBitShiftContext) BIT_SHR() antlr.TerminalNode

func (*ExprBitShiftContext) Expr

func (s *ExprBitShiftContext) Expr(i int) IExprContext

func (*ExprBitShiftContext) GetOp

func (s *ExprBitShiftContext) GetOp() antlr.Token

func (*ExprBitShiftContext) GetRuleContext

func (s *ExprBitShiftContext) GetRuleContext() antlr.RuleContext

func (*ExprBitShiftContext) SetOp

func (s *ExprBitShiftContext) SetOp(v antlr.Token)

type ExprBitXorContext

type ExprBitXorContext struct {
	ExprContext
}

func NewExprBitXorContext

func NewExprBitXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitXorContext

func (*ExprBitXorContext) Accept

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

func (*ExprBitXorContext) AllExpr

func (s *ExprBitXorContext) AllExpr() []IExprContext

func (*ExprBitXorContext) BIT_XOR

func (s *ExprBitXorContext) BIT_XOR() antlr.TerminalNode

func (*ExprBitXorContext) Expr

func (s *ExprBitXorContext) Expr(i int) IExprContext

func (*ExprBitXorContext) GetRuleContext

func (s *ExprBitXorContext) GetRuleContext() antlr.RuleContext

type ExprByFieldContext

type ExprByFieldContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprByFieldContext

func NewExprByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprByFieldContext

func (*ExprByFieldContext) Accept

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

func (*ExprByFieldContext) DOT

func (s *ExprByFieldContext) DOT() antlr.TerminalNode

func (*ExprByFieldContext) Expr

func (s *ExprByFieldContext) Expr() IExprContext

func (*ExprByFieldContext) GetField

func (s *ExprByFieldContext) GetField() antlr.Token

func (*ExprByFieldContext) GetRuleContext

func (s *ExprByFieldContext) GetRuleContext() antlr.RuleContext

func (*ExprByFieldContext) IDENTIFIER

func (s *ExprByFieldContext) IDENTIFIER() antlr.TerminalNode

func (*ExprByFieldContext) SetField

func (s *ExprByFieldContext) SetField(v antlr.Token)

type ExprByIndexContext

type ExprByIndexContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprByIndexContext

func NewExprByIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprByIndexContext

func (*ExprByIndexContext) Accept

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

func (*ExprByIndexContext) AllExpr

func (s *ExprByIndexContext) AllExpr() []IExprContext

func (*ExprByIndexContext) Expr

func (s *ExprByIndexContext) Expr(i int) IExprContext

func (*ExprByIndexContext) GetIndex

func (s *ExprByIndexContext) GetIndex() IExprContext

func (*ExprByIndexContext) GetRuleContext

func (s *ExprByIndexContext) GetRuleContext() antlr.RuleContext

func (*ExprByIndexContext) L_BRACKET

func (s *ExprByIndexContext) L_BRACKET() antlr.TerminalNode

func (*ExprByIndexContext) R_BRACKET

func (s *ExprByIndexContext) R_BRACKET() antlr.TerminalNode

func (*ExprByIndexContext) SetIndex

func (s *ExprByIndexContext) SetIndex(v IExprContext)

type ExprBySliceContext

type ExprBySliceContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprBySliceContext

func NewExprBySliceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBySliceContext

func (*ExprBySliceContext) Accept

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

func (*ExprBySliceContext) AllExpr

func (s *ExprBySliceContext) AllExpr() []IExprContext

func (*ExprBySliceContext) COLON

func (s *ExprBySliceContext) COLON() antlr.TerminalNode

func (*ExprBySliceContext) Expr

func (s *ExprBySliceContext) Expr(i int) IExprContext

func (*ExprBySliceContext) GetBegin

func (s *ExprBySliceContext) GetBegin() IExprContext

func (*ExprBySliceContext) GetContainer

func (s *ExprBySliceContext) GetContainer() IExprContext

func (*ExprBySliceContext) GetEnd

func (s *ExprBySliceContext) GetEnd() IExprContext

func (*ExprBySliceContext) GetRuleContext

func (s *ExprBySliceContext) GetRuleContext() antlr.RuleContext

func (*ExprBySliceContext) L_BRACKET

func (s *ExprBySliceContext) L_BRACKET() antlr.TerminalNode

func (*ExprBySliceContext) R_BRACKET

func (s *ExprBySliceContext) R_BRACKET() antlr.TerminalNode

func (*ExprBySliceContext) SetBegin

func (s *ExprBySliceContext) SetBegin(v IExprContext)

func (*ExprBySliceContext) SetContainer

func (s *ExprBySliceContext) SetContainer(v IExprContext)

func (*ExprBySliceContext) SetEnd

func (s *ExprBySliceContext) SetEnd(v IExprContext)

type ExprCallContext

type ExprCallContext struct {
	ExprContext
}

func NewExprCallContext

func NewExprCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprCallContext

func (*ExprCallContext) Accept

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

func (*ExprCallContext) Arguments

func (s *ExprCallContext) Arguments() IArgumentsContext

func (*ExprCallContext) Expr

func (s *ExprCallContext) Expr() IExprContext

func (*ExprCallContext) GetRuleContext

func (s *ExprCallContext) GetRuleContext() antlr.RuleContext

func (*ExprCallContext) OPTIONAL_CALL

func (s *ExprCallContext) OPTIONAL_CALL() antlr.TerminalNode

type ExprCompareContext

type ExprCompareContext struct {
	ExprContext
}

func NewExprCompareContext

func NewExprCompareContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprCompareContext

func (*ExprCompareContext) Accept

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

func (*ExprCompareContext) AllExpr

func (s *ExprCompareContext) AllExpr() []IExprContext

func (*ExprCompareContext) Comparator

func (s *ExprCompareContext) Comparator() IComparatorContext

func (*ExprCompareContext) Expr

func (s *ExprCompareContext) Expr(i int) IExprContext

func (*ExprCompareContext) GetRuleContext

func (s *ExprCompareContext) GetRuleContext() antlr.RuleContext

type ExprContext

type ExprContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExprContext

func NewEmptyExprContext() *ExprContext

func NewExprContext

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

func (*ExprContext) CopyAll

func (s *ExprContext) CopyAll(ctx *ExprContext)

func (*ExprContext) GetParser

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

func (*ExprContext) GetRuleContext

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

func (*ExprContext) IsExprContext

func (*ExprContext) IsExprContext()

func (*ExprContext) ToStringTree

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

type ExprFallbackContext

type ExprFallbackContext struct {
	ExprContext
}

func NewExprFallbackContext

func NewExprFallbackContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprFallbackContext

func (*ExprFallbackContext) Accept

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

func (*ExprFallbackContext) AllExpr

func (s *ExprFallbackContext) AllExpr() []IExprContext

func (*ExprFallbackContext) Expr

func (s *ExprFallbackContext) Expr(i int) IExprContext

func (*ExprFallbackContext) GetRuleContext

func (s *ExprFallbackContext) GetRuleContext() antlr.RuleContext

func (*ExprFallbackContext) OPTIONAL_ELSE

func (s *ExprFallbackContext) OPTIONAL_ELSE() antlr.TerminalNode

type ExprIdentifierContext

type ExprIdentifierContext struct {
	ExprContext
}

func NewExprIdentifierContext

func NewExprIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprIdentifierContext

func (*ExprIdentifierContext) Accept

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

func (*ExprIdentifierContext) GetRuleContext

func (s *ExprIdentifierContext) GetRuleContext() antlr.RuleContext

func (*ExprIdentifierContext) IDENTIFIER

func (s *ExprIdentifierContext) IDENTIFIER() antlr.TerminalNode

type ExprInContainerContext

type ExprInContainerContext struct {
	ExprContext
}

func NewExprInContainerContext

func NewExprInContainerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprInContainerContext

func (*ExprInContainerContext) Accept

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

func (*ExprInContainerContext) AllExpr

func (s *ExprInContainerContext) AllExpr() []IExprContext

func (*ExprInContainerContext) Expr

func (s *ExprInContainerContext) Expr(i int) IExprContext

func (*ExprInContainerContext) GetRuleContext

func (s *ExprInContainerContext) GetRuleContext() antlr.RuleContext

func (*ExprInContainerContext) IN

func (s *ExprInContainerContext) IN() antlr.TerminalNode

type ExprInRangeContext

type ExprInRangeContext struct {
	ExprContext
}

func NewExprInRangeContext

func NewExprInRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprInRangeContext

func (*ExprInRangeContext) Accept

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

func (*ExprInRangeContext) AllExpr

func (s *ExprInRangeContext) AllExpr() []IExprContext

func (*ExprInRangeContext) Expr

func (s *ExprInRangeContext) Expr(i int) IExprContext

func (*ExprInRangeContext) GetRuleContext

func (s *ExprInRangeContext) GetRuleContext() antlr.RuleContext

func (*ExprInRangeContext) IN

func (s *ExprInRangeContext) IN() antlr.TerminalNode

func (*ExprInRangeContext) RANGE_WITHOUT_END

func (s *ExprInRangeContext) RANGE_WITHOUT_END() antlr.TerminalNode

func (*ExprInRangeContext) RANGE_WITH_END

func (s *ExprInRangeContext) RANGE_WITH_END() antlr.TerminalNode

type ExprIsTypeContext

type ExprIsTypeContext struct {
	ExprContext
}

func NewExprIsTypeContext

func NewExprIsTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprIsTypeContext

func (*ExprIsTypeContext) Accept

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

func (*ExprIsTypeContext) AllExpr

func (s *ExprIsTypeContext) AllExpr() []IExprContext

func (*ExprIsTypeContext) Expr

func (s *ExprIsTypeContext) Expr(i int) IExprContext

func (*ExprIsTypeContext) GetRuleContext

func (s *ExprIsTypeContext) GetRuleContext() antlr.RuleContext

func (*ExprIsTypeContext) IS

func (s *ExprIsTypeContext) IS() antlr.TerminalNode

type ExprItByFieldContext

type ExprItByFieldContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprItByFieldContext

func NewExprItByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprItByFieldContext

func (*ExprItByFieldContext) Accept

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

func (*ExprItByFieldContext) DOT

func (s *ExprItByFieldContext) DOT() antlr.TerminalNode

func (*ExprItByFieldContext) GetField

func (s *ExprItByFieldContext) GetField() antlr.Token

func (*ExprItByFieldContext) GetRuleContext

func (s *ExprItByFieldContext) GetRuleContext() antlr.RuleContext

func (*ExprItByFieldContext) IDENTIFIER

func (s *ExprItByFieldContext) IDENTIFIER() antlr.TerminalNode

func (*ExprItByFieldContext) SetField

func (s *ExprItByFieldContext) SetField(v antlr.Token)

type ExprLiteralContext

type ExprLiteralContext struct {
	ExprContext
}

func NewExprLiteralContext

func NewExprLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLiteralContext

func (*ExprLiteralContext) Accept

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

func (*ExprLiteralContext) GetRuleContext

func (s *ExprLiteralContext) GetRuleContext() antlr.RuleContext

func (*ExprLiteralContext) Literal

func (s *ExprLiteralContext) Literal() ILiteralContext

type ExprLogicAndContext

type ExprLogicAndContext struct {
	ExprContext
}

func NewExprLogicAndContext

func NewExprLogicAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicAndContext

func (*ExprLogicAndContext) Accept

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

func (*ExprLogicAndContext) AllExpr

func (s *ExprLogicAndContext) AllExpr() []IExprContext

func (*ExprLogicAndContext) Expr

func (s *ExprLogicAndContext) Expr(i int) IExprContext

func (*ExprLogicAndContext) GetRuleContext

func (s *ExprLogicAndContext) GetRuleContext() antlr.RuleContext

func (*ExprLogicAndContext) LOGIC_AND

func (s *ExprLogicAndContext) LOGIC_AND() antlr.TerminalNode

type ExprLogicNotContext

type ExprLogicNotContext struct {
	ExprContext
}

func NewExprLogicNotContext

func NewExprLogicNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicNotContext

func (*ExprLogicNotContext) Accept

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

func (*ExprLogicNotContext) Expr

func (s *ExprLogicNotContext) Expr() IExprContext

func (*ExprLogicNotContext) GetRuleContext

func (s *ExprLogicNotContext) GetRuleContext() antlr.RuleContext

func (*ExprLogicNotContext) LOGIC_NOT

func (s *ExprLogicNotContext) LOGIC_NOT() antlr.TerminalNode

type ExprLogicOrContext

type ExprLogicOrContext struct {
	ExprContext
}

func NewExprLogicOrContext

func NewExprLogicOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicOrContext

func (*ExprLogicOrContext) Accept

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

func (*ExprLogicOrContext) AllExpr

func (s *ExprLogicOrContext) AllExpr() []IExprContext

func (*ExprLogicOrContext) Expr

func (s *ExprLogicOrContext) Expr(i int) IExprContext

func (*ExprLogicOrContext) GetRuleContext

func (s *ExprLogicOrContext) GetRuleContext() antlr.RuleContext

func (*ExprLogicOrContext) LOGIC_OR

func (s *ExprLogicOrContext) LOGIC_OR() antlr.TerminalNode

type ExprNegativeContext

type ExprNegativeContext struct {
	ExprContext
}

func NewExprNegativeContext

func NewExprNegativeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprNegativeContext

func (*ExprNegativeContext) Accept

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

func (*ExprNegativeContext) Expr

func (s *ExprNegativeContext) Expr() IExprContext

func (*ExprNegativeContext) GetRuleContext

func (s *ExprNegativeContext) GetRuleContext() antlr.RuleContext

func (*ExprNegativeContext) MINUS

func (s *ExprNegativeContext) MINUS() antlr.TerminalNode

type ExprPlusMinusContext

type ExprPlusMinusContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprPlusMinusContext

func NewExprPlusMinusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPlusMinusContext

func (*ExprPlusMinusContext) Accept

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

func (*ExprPlusMinusContext) AllExpr

func (s *ExprPlusMinusContext) AllExpr() []IExprContext

func (*ExprPlusMinusContext) Expr

func (s *ExprPlusMinusContext) Expr(i int) IExprContext

func (*ExprPlusMinusContext) GetOp

func (s *ExprPlusMinusContext) GetOp() antlr.Token

func (*ExprPlusMinusContext) GetRuleContext

func (s *ExprPlusMinusContext) GetRuleContext() antlr.RuleContext

func (*ExprPlusMinusContext) MINUS

func (s *ExprPlusMinusContext) MINUS() antlr.TerminalNode

func (*ExprPlusMinusContext) PLUS

func (s *ExprPlusMinusContext) PLUS() antlr.TerminalNode

func (*ExprPlusMinusContext) SetOp

func (s *ExprPlusMinusContext) SetOp(v antlr.Token)

type ExprPostIncDecContext

type ExprPostIncDecContext struct {
	ExprContext
}

func NewExprPostIncDecContext

func NewExprPostIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPostIncDecContext

func (*ExprPostIncDecContext) Accept

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

func (*ExprPostIncDecContext) GetRuleContext

func (s *ExprPostIncDecContext) GetRuleContext() antlr.RuleContext

func (*ExprPostIncDecContext) PostIncDec

func (s *ExprPostIncDecContext) PostIncDec() IPostIncDecContext

type ExprPowContext

type ExprPowContext struct {
	ExprContext
}

func NewExprPowContext

func NewExprPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPowContext

func (*ExprPowContext) Accept

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

func (*ExprPowContext) AllExpr

func (s *ExprPowContext) AllExpr() []IExprContext

func (*ExprPowContext) Expr

func (s *ExprPowContext) Expr(i int) IExprContext

func (*ExprPowContext) GetRuleContext

func (s *ExprPowContext) GetRuleContext() antlr.RuleContext

func (*ExprPowContext) POW

func (s *ExprPowContext) POW() antlr.TerminalNode

type ExprPreIncDecContext

type ExprPreIncDecContext struct {
	ExprContext
}

func NewExprPreIncDecContext

func NewExprPreIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPreIncDecContext

func (*ExprPreIncDecContext) Accept

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

func (*ExprPreIncDecContext) GetRuleContext

func (s *ExprPreIncDecContext) GetRuleContext() antlr.RuleContext

func (*ExprPreIncDecContext) PreIncDec

func (s *ExprPreIncDecContext) PreIncDec() IPreIncDecContext

type ExprQuestionContext

type ExprQuestionContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprQuestionContext

func NewExprQuestionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprQuestionContext

func (*ExprQuestionContext) Accept

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

func (*ExprQuestionContext) AllExpr

func (s *ExprQuestionContext) AllExpr() []IExprContext

func (*ExprQuestionContext) COLON

func (s *ExprQuestionContext) COLON() antlr.TerminalNode

func (*ExprQuestionContext) Expr

func (s *ExprQuestionContext) Expr(i int) IExprContext

func (*ExprQuestionContext) GetCondition

func (s *ExprQuestionContext) GetCondition() IExprContext

func (*ExprQuestionContext) GetFalseExpr

func (s *ExprQuestionContext) GetFalseExpr() IExprContext

func (*ExprQuestionContext) GetRuleContext

func (s *ExprQuestionContext) GetRuleContext() antlr.RuleContext

func (*ExprQuestionContext) GetTrueExpr

func (s *ExprQuestionContext) GetTrueExpr() IExprContext

func (*ExprQuestionContext) QUESTION

func (s *ExprQuestionContext) QUESTION() antlr.TerminalNode

func (*ExprQuestionContext) SetCondition

func (s *ExprQuestionContext) SetCondition(v IExprContext)

func (*ExprQuestionContext) SetFalseExpr

func (s *ExprQuestionContext) SetFalseExpr(v IExprContext)

func (*ExprQuestionContext) SetTrueExpr

func (s *ExprQuestionContext) SetTrueExpr(v IExprContext)

type ExprShortImportContext

type ExprShortImportContext struct {
	ExprContext
}

func NewExprShortImportContext

func NewExprShortImportContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprShortImportContext

func (*ExprShortImportContext) Accept

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

func (*ExprShortImportContext) DOUBLE_AT

func (s *ExprShortImportContext) DOUBLE_AT() antlr.TerminalNode

func (*ExprShortImportContext) GetRuleContext

func (s *ExprShortImportContext) GetRuleContext() antlr.RuleContext

func (*ExprShortImportContext) IDENTIFIER

func (s *ExprShortImportContext) IDENTIFIER() antlr.TerminalNode

func (*ExprShortImportContext) SINGLE_AT

func (s *ExprShortImportContext) SINGLE_AT() antlr.TerminalNode

type ExprSubContext

type ExprSubContext struct {
	ExprContext
}

func NewExprSubContext

func NewExprSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprSubContext

func (*ExprSubContext) Accept

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

func (*ExprSubContext) Expr

func (s *ExprSubContext) Expr() IExprContext

func (*ExprSubContext) GetRuleContext

func (s *ExprSubContext) GetRuleContext() antlr.RuleContext

func (*ExprSubContext) L_PAREN

func (s *ExprSubContext) L_PAREN() antlr.TerminalNode

func (*ExprSubContext) R_PAREN

func (s *ExprSubContext) R_PAREN() antlr.TerminalNode

type ExprTimesDivModContext

type ExprTimesDivModContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprTimesDivModContext

func NewExprTimesDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprTimesDivModContext

func (*ExprTimesDivModContext) Accept

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

func (*ExprTimesDivModContext) AllExpr

func (s *ExprTimesDivModContext) AllExpr() []IExprContext

func (*ExprTimesDivModContext) DIV

func (s *ExprTimesDivModContext) DIV() antlr.TerminalNode

func (*ExprTimesDivModContext) Expr

func (s *ExprTimesDivModContext) Expr(i int) IExprContext

func (*ExprTimesDivModContext) GetOp

func (s *ExprTimesDivModContext) GetOp() antlr.Token

func (*ExprTimesDivModContext) GetRuleContext

func (s *ExprTimesDivModContext) GetRuleContext() antlr.RuleContext

func (*ExprTimesDivModContext) MOD

func (s *ExprTimesDivModContext) MOD() antlr.TerminalNode

func (*ExprTimesDivModContext) SetOp

func (s *ExprTimesDivModContext) SetOp(v antlr.Token)

func (*ExprTimesDivModContext) TIMES

func (s *ExprTimesDivModContext) TIMES() antlr.TerminalNode

type ExprUseBlockContext

type ExprUseBlockContext struct {
	ExprContext
}

func NewExprUseBlockContext

func NewExprUseBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseBlockContext

func (*ExprUseBlockContext) Accept

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

func (*ExprUseBlockContext) CodeBlock

func (s *ExprUseBlockContext) CodeBlock() ICodeBlockContext

func (*ExprUseBlockContext) Expr

func (s *ExprUseBlockContext) Expr() IExprContext

func (*ExprUseBlockContext) GetRuleContext

func (s *ExprUseBlockContext) GetRuleContext() antlr.RuleContext

func (*ExprUseBlockContext) USE_AT

func (s *ExprUseBlockContext) USE_AT() antlr.TerminalNode

type ExprUseCloserContext

type ExprUseCloserContext struct {
	ExprContext
}

func NewExprUseCloserContext

func NewExprUseCloserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseCloserContext

func (*ExprUseCloserContext) Accept

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

func (*ExprUseCloserContext) Expr

func (s *ExprUseCloserContext) Expr() IExprContext

func (*ExprUseCloserContext) GetRuleContext

func (s *ExprUseCloserContext) GetRuleContext() antlr.RuleContext

func (*ExprUseCloserContext) USE

func (s *ExprUseCloserContext) USE() antlr.TerminalNode

type ExprUseMethodContext

type ExprUseMethodContext struct {
	ExprContext
}

func NewExprUseMethodContext

func NewExprUseMethodContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUseMethodContext

func (*ExprUseMethodContext) Accept

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

func (*ExprUseMethodContext) Expr

func (s *ExprUseMethodContext) Expr() IExprContext

func (*ExprUseMethodContext) GetRuleContext

func (s *ExprUseMethodContext) GetRuleContext() antlr.RuleContext

func (*ExprUseMethodContext) IDENTIFIER

func (s *ExprUseMethodContext) IDENTIFIER() antlr.TerminalNode

func (*ExprUseMethodContext) USE_AT

func (s *ExprUseMethodContext) USE_AT() antlr.TerminalNode

type ExprWhenContext

type ExprWhenContext struct {
	ExprContext
}

func NewExprWhenContext

func NewExprWhenContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprWhenContext

func (*ExprWhenContext) Accept

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

func (*ExprWhenContext) AllExpr

func (s *ExprWhenContext) AllExpr() []IExprContext

func (*ExprWhenContext) AllLEAD_TO

func (s *ExprWhenContext) AllLEAD_TO() []antlr.TerminalNode

func (*ExprWhenContext) ELSE

func (s *ExprWhenContext) ELSE() antlr.TerminalNode

func (*ExprWhenContext) Expr

func (s *ExprWhenContext) Expr(i int) IExprContext

func (*ExprWhenContext) GetRuleContext

func (s *ExprWhenContext) GetRuleContext() antlr.RuleContext

func (*ExprWhenContext) LEAD_TO

func (s *ExprWhenContext) LEAD_TO(i int) antlr.TerminalNode

func (*ExprWhenContext) L_CURLY

func (s *ExprWhenContext) L_CURLY() antlr.TerminalNode

func (*ExprWhenContext) R_CURLY

func (s *ExprWhenContext) R_CURLY() antlr.TerminalNode

func (*ExprWhenContext) WHEN

func (s *ExprWhenContext) WHEN() antlr.TerminalNode

type ExprWhenValueContext

type ExprWhenValueContext struct {
	ExprContext
}

func NewExprWhenValueContext

func NewExprWhenValueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprWhenValueContext

func (*ExprWhenValueContext) Accept

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

func (*ExprWhenValueContext) AllExpr

func (s *ExprWhenValueContext) AllExpr() []IExprContext

func (*ExprWhenValueContext) AllLEAD_TO

func (s *ExprWhenValueContext) AllLEAD_TO() []antlr.TerminalNode

func (*ExprWhenValueContext) AllWhenCondition

func (s *ExprWhenValueContext) AllWhenCondition() []IWhenConditionContext

func (*ExprWhenValueContext) ELSE

func (s *ExprWhenValueContext) ELSE() antlr.TerminalNode

func (*ExprWhenValueContext) Expr

func (s *ExprWhenValueContext) Expr(i int) IExprContext

func (*ExprWhenValueContext) GetRuleContext

func (s *ExprWhenValueContext) GetRuleContext() antlr.RuleContext

func (*ExprWhenValueContext) LEAD_TO

func (s *ExprWhenValueContext) LEAD_TO(i int) antlr.TerminalNode

func (*ExprWhenValueContext) L_CURLY

func (s *ExprWhenValueContext) L_CURLY() antlr.TerminalNode

func (*ExprWhenValueContext) R_CURLY

func (s *ExprWhenValueContext) R_CURLY() antlr.TerminalNode

func (*ExprWhenValueContext) WHEN

func (s *ExprWhenValueContext) WHEN() antlr.TerminalNode

func (*ExprWhenValueContext) WhenCondition

func (s *ExprWhenValueContext) WhenCondition(i int) IWhenConditionContext

type FuncArgumentContext

type FuncArgumentContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFuncArgumentContext

func NewEmptyFuncArgumentContext() *FuncArgumentContext

func NewFuncArgumentContext

func NewFuncArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FuncArgumentContext

func (*FuncArgumentContext) Accept

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

func (*FuncArgumentContext) COLON

func (s *FuncArgumentContext) COLON() antlr.TerminalNode

func (*FuncArgumentContext) CodeBlock

func (s *FuncArgumentContext) CodeBlock() ICodeBlockContext

func (*FuncArgumentContext) Expr

func (s *FuncArgumentContext) Expr() IExprContext

func (*FuncArgumentContext) GetHoleIndex

func (s *FuncArgumentContext) GetHoleIndex() antlr.Token

func (*FuncArgumentContext) GetLambdaExpr

func (s *FuncArgumentContext) GetLambdaExpr() IExprContext

func (*FuncArgumentContext) GetParser

func (s *FuncArgumentContext) GetParser() antlr.Parser

func (*FuncArgumentContext) GetPlaceholder

func (s *FuncArgumentContext) GetPlaceholder() antlr.Token

func (*FuncArgumentContext) GetRuleContext

func (s *FuncArgumentContext) GetRuleContext() antlr.RuleContext

func (*FuncArgumentContext) GetSimpleArg

func (s *FuncArgumentContext) GetSimpleArg() IExprContext

func (*FuncArgumentContext) IDENTIFIER

func (s *FuncArgumentContext) IDENTIFIER() antlr.TerminalNode

func (*FuncArgumentContext) INT_DEC

func (s *FuncArgumentContext) INT_DEC() antlr.TerminalNode

func (*FuncArgumentContext) INT_ZERO

func (s *FuncArgumentContext) INT_ZERO() antlr.TerminalNode

func (*FuncArgumentContext) IsFuncArgumentContext

func (*FuncArgumentContext) IsFuncArgumentContext()

func (*FuncArgumentContext) L_CURLY

func (s *FuncArgumentContext) L_CURLY() antlr.TerminalNode

func (*FuncArgumentContext) MOD

func (s *FuncArgumentContext) MOD() antlr.TerminalNode

func (*FuncArgumentContext) MORE_ARGS

func (s *FuncArgumentContext) MORE_ARGS() antlr.TerminalNode

func (*FuncArgumentContext) R_CURLY

func (s *FuncArgumentContext) R_CURLY() antlr.TerminalNode

func (*FuncArgumentContext) SetHoleIndex

func (s *FuncArgumentContext) SetHoleIndex(v antlr.Token)

func (*FuncArgumentContext) SetLambdaExpr

func (s *FuncArgumentContext) SetLambdaExpr(v IExprContext)

func (*FuncArgumentContext) SetPlaceholder

func (s *FuncArgumentContext) SetPlaceholder(v antlr.Token)

func (*FuncArgumentContext) SetSimpleArg

func (s *FuncArgumentContext) SetSimpleArg(v IExprContext)

func (*FuncArgumentContext) ToStringTree

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

type IArgumentsContext

type IArgumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	L_PAREN() antlr.TerminalNode
	R_PAREN() antlr.TerminalNode
	AllFuncArgument() []IFuncArgumentContext
	FuncArgument(i int) IFuncArgumentContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsArgumentsContext differentiates from other interfaces.
	IsArgumentsContext()
}

IArgumentsContext is an interface to support dynamic dispatch.

type IArrayItemContext

type IArrayItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCondition returns the condition rule contexts.
	GetCondition() IExprContext

	// SetCondition sets the condition rule contexts.
	SetCondition(IExprContext)

	// Getter signatures
	AllExpr() []IExprContext
	Expr(i int) IExprContext
	MORE_ARGS() antlr.TerminalNode
	IF() antlr.TerminalNode

	// IsArrayItemContext differentiates from other interfaces.
	IsArrayItemContext()
}

IArrayItemContext is an interface to support dynamic dispatch.

type IAssignExprContext

type IAssignExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsAssignExprContext differentiates from other interfaces.
	IsAssignExprContext()
}

IAssignExprContext is an interface to support dynamic dispatch.

type IBlockContext

type IBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllStmt() []IStmtContext
	Stmt(i int) IStmtContext
	AllSEMICOLON() []antlr.TerminalNode
	SEMICOLON(i int) antlr.TerminalNode

	// IsBlockContext differentiates from other interfaces.
	IsBlockContext()
}

IBlockContext is an interface to support dynamic dispatch.

type ICallStmtContext

type ICallStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expr() IExprContext
	Arguments() IArgumentsContext
	OPTIONAL_CALL() antlr.TerminalNode
	OPTIONAL_ELSE() antlr.TerminalNode
	CodeBlock() ICodeBlockContext

	// IsCallStmtContext differentiates from other interfaces.
	IsCallStmtContext()
}

ICallStmtContext is an interface to support dynamic dispatch.

type ICodeBlockContext

type ICodeBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	L_CURLY() antlr.TerminalNode
	Block() IBlockContext
	R_CURLY() antlr.TerminalNode

	// IsCodeBlockContext differentiates from other interfaces.
	IsCodeBlockContext()
}

ICodeBlockContext is an interface to support dynamic dispatch.

type IComparatorContext

type IComparatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EQUAL() antlr.TerminalNode
	NOT_EQUAL() antlr.TerminalNode
	GTEQ() antlr.TerminalNode
	LTEQ() antlr.TerminalNode
	LT() antlr.TerminalNode
	GT() antlr.TerminalNode

	// IsComparatorContext differentiates from other interfaces.
	IsComparatorContext()
}

IComparatorContext is an interface to support dynamic dispatch.

type IExprContext

type IExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsExprContext differentiates from other interfaces.
	IsExprContext()
}

IExprContext is an interface to support dynamic dispatch.

type IFuncArgumentContext

type IFuncArgumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPlaceholder returns the placeholder token.
	GetPlaceholder() antlr.Token

	// GetHoleIndex returns the holeIndex token.
	GetHoleIndex() antlr.Token

	// SetPlaceholder sets the placeholder token.
	SetPlaceholder(antlr.Token)

	// SetHoleIndex sets the holeIndex token.
	SetHoleIndex(antlr.Token)

	// GetSimpleArg returns the simpleArg rule contexts.
	GetSimpleArg() IExprContext

	// GetLambdaExpr returns the lambdaExpr rule contexts.
	GetLambdaExpr() IExprContext

	// SetSimpleArg sets the simpleArg rule contexts.
	SetSimpleArg(IExprContext)

	// SetLambdaExpr sets the lambdaExpr rule contexts.
	SetLambdaExpr(IExprContext)

	// Getter signatures
	CodeBlock() ICodeBlockContext
	L_CURLY() antlr.TerminalNode
	R_CURLY() antlr.TerminalNode
	Expr() IExprContext
	MORE_ARGS() antlr.TerminalNode
	IDENTIFIER() antlr.TerminalNode
	COLON() antlr.TerminalNode
	MOD() antlr.TerminalNode
	INT_ZERO() antlr.TerminalNode
	INT_DEC() antlr.TerminalNode

	// IsFuncArgumentContext differentiates from other interfaces.
	IsFuncArgumentContext()
}

IFuncArgumentContext is an interface to support dynamic dispatch.

type IIfConditionContext

type IIfConditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expr() IExprContext
	AssignExpr() IAssignExprContext
	SEMICOLON() antlr.TerminalNode

	// IsIfConditionContext differentiates from other interfaces.
	IsIfConditionContext()
}

IIfConditionContext is an interface to support dynamic dispatch.

type IIntegerContext

type IIntegerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsIntegerContext differentiates from other interfaces.
	IsIntegerContext()
}

IIntegerContext is an interface to support dynamic dispatch.

type IKeyValueContext

type IKeyValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsKeyValueContext differentiates from other interfaces.
	IsKeyValueContext()
}

IKeyValueContext is an interface to support dynamic dispatch.

type ILiteralContext

type ILiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsLiteralContext differentiates from other interfaces.
	IsLiteralContext()
}

ILiteralContext is an interface to support dynamic dispatch.

type ILvalContext

type ILvalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsLvalContext differentiates from other interfaces.
	IsLvalContext()
}

ILvalContext is an interface to support dynamic dispatch.

type IMemberDefContext

type IMemberDefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	KeyValue() IKeyValueContext
	STATIC() antlr.TerminalNode

	// IsMemberDefContext differentiates from other interfaces.
	IsMemberDefContext()
}

IMemberDefContext is an interface to support dynamic dispatch.

type IModuleContext

type IModuleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Block() IBlockContext

	// IsModuleContext differentiates from other interfaces.
	IsModuleContext()
}

IModuleContext is an interface to support dynamic dispatch.

type IObjItemContext

type IObjItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsObjItemContext differentiates from other interfaces.
	IsObjItemContext()
}

IObjItemContext is an interface to support dynamic dispatch.

type IPostIncDecContext

type IPostIncDecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the op token.
	GetOp() antlr.Token

	// SetOp sets the op token.
	SetOp(antlr.Token)

	// Getter signatures
	Lval() ILvalContext
	PLUS_PLUS() antlr.TerminalNode
	MINUS_MINUS() antlr.TerminalNode

	// IsPostIncDecContext differentiates from other interfaces.
	IsPostIncDecContext()
}

IPostIncDecContext is an interface to support dynamic dispatch.

type IPreIncDecContext

type IPreIncDecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the op token.
	GetOp() antlr.Token

	// SetOp sets the op token.
	SetOp(antlr.Token)

	// Getter signatures
	Lval() ILvalContext
	PLUS_PLUS() antlr.TerminalNode
	MINUS_MINUS() antlr.TerminalNode

	// IsPreIncDecContext differentiates from other interfaces.
	IsPreIncDecContext()
}

IPreIncDecContext is an interface to support dynamic dispatch.

type IReplItemContext

type IReplItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsReplItemContext differentiates from other interfaces.
	IsReplItemContext()
}

IReplItemContext is an interface to support dynamic dispatch.

type IStmtContext

type IStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsStmtContext differentiates from other interfaces.
	IsStmtContext()
}

IStmtContext is an interface to support dynamic dispatch.

type IStringLiteralContext

type IStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STRING() antlr.TerminalNode
	RSTRING() antlr.TerminalNode
	TemplateString() ITemplateStringContext

	// IsStringLiteralContext differentiates from other interfaces.
	IsStringLiteralContext()
}

IStringLiteralContext is an interface to support dynamic dispatch.

type ISwitchCaseContext

type ISwitchCaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CASE() antlr.TerminalNode
	WhenCondition() IWhenConditionContext
	COLON() antlr.TerminalNode
	Block() IBlockContext
	FALLTHROUGH() antlr.TerminalNode

	// IsSwitchCaseContext differentiates from other interfaces.
	IsSwitchCaseContext()
}

ISwitchCaseContext is an interface to support dynamic dispatch.

type ISwitchDefaultContext

type ISwitchDefaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEFAULT() antlr.TerminalNode
	COLON() antlr.TerminalNode
	Block() IBlockContext

	// IsSwitchDefaultContext differentiates from other interfaces.
	IsSwitchDefaultContext()
}

ISwitchDefaultContext is an interface to support dynamic dispatch.

type ITemplateStringContext

type ITemplateStringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllQUOTE() []antlr.TerminalNode
	QUOTE(i int) antlr.TerminalNode
	AllTsItem() []ITsItemContext
	TsItem(i int) ITsItemContext

	// IsTemplateStringContext differentiates from other interfaces.
	IsTemplateStringContext()
}

ITemplateStringContext is an interface to support dynamic dispatch.

type ITsItemContext

type ITsItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsTsItemContext differentiates from other interfaces.
	IsTsItemContext()
}

ITsItemContext is an interface to support dynamic dispatch.

type IWhenConditionContext

type IWhenConditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsWhenConditionContext differentiates from other interfaces.
	IsWhenConditionContext()
}

IWhenConditionContext is an interface to support dynamic dispatch.

type IfConditionContext

type IfConditionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIfConditionContext

func NewEmptyIfConditionContext() *IfConditionContext

func NewIfConditionContext

func NewIfConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionContext

func (*IfConditionContext) Accept

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

func (*IfConditionContext) AssignExpr

func (s *IfConditionContext) AssignExpr() IAssignExprContext

func (*IfConditionContext) Expr

func (s *IfConditionContext) Expr() IExprContext

func (*IfConditionContext) GetParser

func (s *IfConditionContext) GetParser() antlr.Parser

func (*IfConditionContext) GetRuleContext

func (s *IfConditionContext) GetRuleContext() antlr.RuleContext

func (*IfConditionContext) IsIfConditionContext

func (*IfConditionContext) IsIfConditionContext()

func (*IfConditionContext) SEMICOLON

func (s *IfConditionContext) SEMICOLON() antlr.TerminalNode

func (*IfConditionContext) ToStringTree

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

type IntegerBinContext

type IntegerBinContext struct {
	IntegerContext
}

func NewIntegerBinContext

func NewIntegerBinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerBinContext

func (*IntegerBinContext) Accept

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

func (*IntegerBinContext) GetRuleContext

func (s *IntegerBinContext) GetRuleContext() antlr.RuleContext

func (*IntegerBinContext) INT_BIN

func (s *IntegerBinContext) INT_BIN() antlr.TerminalNode

type IntegerContext

type IntegerContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIntegerContext

func NewEmptyIntegerContext() *IntegerContext

func NewIntegerContext

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

func (*IntegerContext) CopyAll

func (s *IntegerContext) CopyAll(ctx *IntegerContext)

func (*IntegerContext) GetParser

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

func (*IntegerContext) GetRuleContext

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

func (*IntegerContext) IsIntegerContext

func (*IntegerContext) IsIntegerContext()

func (*IntegerContext) ToStringTree

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

type IntegerDecContext

type IntegerDecContext struct {
	IntegerContext
}

func NewIntegerDecContext

func NewIntegerDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerDecContext

func (*IntegerDecContext) Accept

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

func (*IntegerDecContext) GetRuleContext

func (s *IntegerDecContext) GetRuleContext() antlr.RuleContext

func (*IntegerDecContext) INT_DEC

func (s *IntegerDecContext) INT_DEC() antlr.TerminalNode

type IntegerHexContext

type IntegerHexContext struct {
	IntegerContext
}

func NewIntegerHexContext

func NewIntegerHexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerHexContext

func (*IntegerHexContext) Accept

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

func (*IntegerHexContext) GetRuleContext

func (s *IntegerHexContext) GetRuleContext() antlr.RuleContext

func (*IntegerHexContext) INT_HEX

func (s *IntegerHexContext) INT_HEX() antlr.TerminalNode

type IntegerOctContext

type IntegerOctContext struct {
	IntegerContext
}

func NewIntegerOctContext

func NewIntegerOctContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerOctContext

func (*IntegerOctContext) Accept

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

func (*IntegerOctContext) GetRuleContext

func (s *IntegerOctContext) GetRuleContext() antlr.RuleContext

func (*IntegerOctContext) INT_OCT

func (s *IntegerOctContext) INT_OCT() antlr.TerminalNode

type IntegerZeroContext

type IntegerZeroContext struct {
	IntegerContext
}

func NewIntegerZeroContext

func NewIntegerZeroContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerZeroContext

func (*IntegerZeroContext) Accept

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

func (*IntegerZeroContext) GetRuleContext

func (s *IntegerZeroContext) GetRuleContext() antlr.RuleContext

func (*IntegerZeroContext) INT_ZERO

func (s *IntegerZeroContext) INT_ZERO() antlr.TerminalNode

type KVExprKeyContext

type KVExprKeyContext struct {
	KeyValueContext
}

func NewKVExprKeyContext

func NewKVExprKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVExprKeyContext

func (*KVExprKeyContext) Accept

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

func (*KVExprKeyContext) AllExpr

func (s *KVExprKeyContext) AllExpr() []IExprContext

func (*KVExprKeyContext) COLON

func (s *KVExprKeyContext) COLON() antlr.TerminalNode

func (*KVExprKeyContext) Expr

func (s *KVExprKeyContext) Expr(i int) IExprContext

func (*KVExprKeyContext) GetRuleContext

func (s *KVExprKeyContext) GetRuleContext() antlr.RuleContext

func (*KVExprKeyContext) L_BRACKET

func (s *KVExprKeyContext) L_BRACKET() antlr.TerminalNode

func (*KVExprKeyContext) R_BRACKET

func (s *KVExprKeyContext) R_BRACKET() antlr.TerminalNode

type KVExprOnlyContext

type KVExprOnlyContext struct {
	KeyValueContext
}

func NewKVExprOnlyContext

func NewKVExprOnlyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVExprOnlyContext

func (*KVExprOnlyContext) Accept

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

func (*KVExprOnlyContext) Expr

func (s *KVExprOnlyContext) Expr() IExprContext

func (*KVExprOnlyContext) GetRuleContext

func (s *KVExprOnlyContext) GetRuleContext() antlr.RuleContext

func (*KVExprOnlyContext) L_BRACKET

func (s *KVExprOnlyContext) L_BRACKET() antlr.TerminalNode

func (*KVExprOnlyContext) R_BRACKET

func (s *KVExprOnlyContext) R_BRACKET() antlr.TerminalNode

type KVIdKeyContext

type KVIdKeyContext struct {
	KeyValueContext
}

func NewKVIdKeyContext

func NewKVIdKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVIdKeyContext

func (*KVIdKeyContext) Accept

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

func (*KVIdKeyContext) COLON

func (s *KVIdKeyContext) COLON() antlr.TerminalNode

func (*KVIdKeyContext) Expr

func (s *KVIdKeyContext) Expr() IExprContext

func (*KVIdKeyContext) GetRuleContext

func (s *KVIdKeyContext) GetRuleContext() antlr.RuleContext

func (*KVIdKeyContext) IDENTIFIER

func (s *KVIdKeyContext) IDENTIFIER() antlr.TerminalNode

type KVIdOnlyContext

type KVIdOnlyContext struct {
	KeyValueContext
}

func NewKVIdOnlyContext

func NewKVIdOnlyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVIdOnlyContext

func (*KVIdOnlyContext) Accept

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

func (*KVIdOnlyContext) GetRuleContext

func (s *KVIdOnlyContext) GetRuleContext() antlr.RuleContext

func (*KVIdOnlyContext) IDENTIFIER

func (s *KVIdOnlyContext) IDENTIFIER() antlr.TerminalNode

type KVKeyFuncContext

type KVKeyFuncContext struct {
	KeyValueContext
}

func NewKVKeyFuncContext

func NewKVKeyFuncContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVKeyFuncContext

func (*KVKeyFuncContext) Accept

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

func (*KVKeyFuncContext) AllCOMMA

func (s *KVKeyFuncContext) AllCOMMA() []antlr.TerminalNode

func (*KVKeyFuncContext) AllIDENTIFIER

func (s *KVKeyFuncContext) AllIDENTIFIER() []antlr.TerminalNode

func (*KVKeyFuncContext) COMMA

func (s *KVKeyFuncContext) COMMA(i int) antlr.TerminalNode

func (*KVKeyFuncContext) CodeBlock

func (s *KVKeyFuncContext) CodeBlock() ICodeBlockContext

func (*KVKeyFuncContext) GetRuleContext

func (s *KVKeyFuncContext) GetRuleContext() antlr.RuleContext

func (*KVKeyFuncContext) IDENTIFIER

func (s *KVKeyFuncContext) IDENTIFIER(i int) antlr.TerminalNode

func (*KVKeyFuncContext) L_PAREN

func (s *KVKeyFuncContext) L_PAREN() antlr.TerminalNode

func (*KVKeyFuncContext) MORE_ARGS

func (s *KVKeyFuncContext) MORE_ARGS() antlr.TerminalNode

func (*KVKeyFuncContext) R_PAREN

func (s *KVKeyFuncContext) R_PAREN() antlr.TerminalNode

type KVStrKeyContext

type KVStrKeyContext struct {
	KeyValueContext
}

func NewKVStrKeyContext

func NewKVStrKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KVStrKeyContext

func (*KVStrKeyContext) Accept

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

func (*KVStrKeyContext) COLON

func (s *KVStrKeyContext) COLON() antlr.TerminalNode

func (*KVStrKeyContext) Expr

func (s *KVStrKeyContext) Expr() IExprContext

func (*KVStrKeyContext) GetRuleContext

func (s *KVStrKeyContext) GetRuleContext() antlr.RuleContext

func (*KVStrKeyContext) StringLiteral

func (s *KVStrKeyContext) StringLiteral() IStringLiteralContext

type KeyValueContext

type KeyValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKeyValueContext

func NewEmptyKeyValueContext() *KeyValueContext

func NewKeyValueContext

func NewKeyValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyValueContext

func (*KeyValueContext) CopyAll

func (s *KeyValueContext) CopyAll(ctx *KeyValueContext)

func (*KeyValueContext) GetParser

func (s *KeyValueContext) GetParser() antlr.Parser

func (*KeyValueContext) GetRuleContext

func (s *KeyValueContext) GetRuleContext() antlr.RuleContext

func (*KeyValueContext) IsKeyValueContext

func (*KeyValueContext) IsKeyValueContext()

func (*KeyValueContext) ToStringTree

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

type LiteralArrayContext

type LiteralArrayContext struct {
	LiteralContext
}

func NewLiteralArrayContext

func NewLiteralArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralArrayContext

func (*LiteralArrayContext) Accept

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

func (*LiteralArrayContext) AllArrayItem

func (s *LiteralArrayContext) AllArrayItem() []IArrayItemContext

func (*LiteralArrayContext) AllCOMMA

func (s *LiteralArrayContext) AllCOMMA() []antlr.TerminalNode

func (*LiteralArrayContext) ArrayItem

func (s *LiteralArrayContext) ArrayItem(i int) IArrayItemContext

func (*LiteralArrayContext) COMMA

func (s *LiteralArrayContext) COMMA(i int) antlr.TerminalNode

func (*LiteralArrayContext) GetRuleContext

func (s *LiteralArrayContext) GetRuleContext() antlr.RuleContext

func (*LiteralArrayContext) L_BRACKET

func (s *LiteralArrayContext) L_BRACKET() antlr.TerminalNode

func (*LiteralArrayContext) R_BRACKET

func (s *LiteralArrayContext) R_BRACKET() antlr.TerminalNode

type LiteralBigNumContext

type LiteralBigNumContext struct {
	LiteralContext
}

func NewLiteralBigNumContext

func NewLiteralBigNumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralBigNumContext

func (*LiteralBigNumContext) Accept

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

func (*LiteralBigNumContext) BIGNUM

func (s *LiteralBigNumContext) BIGNUM() antlr.TerminalNode

func (*LiteralBigNumContext) GetRuleContext

func (s *LiteralBigNumContext) GetRuleContext() antlr.RuleContext

type LiteralBoolContext

type LiteralBoolContext struct {
	LiteralContext
}

func NewLiteralBoolContext

func NewLiteralBoolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralBoolContext

func (*LiteralBoolContext) Accept

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

func (*LiteralBoolContext) FALSE

func (s *LiteralBoolContext) FALSE() antlr.TerminalNode

func (*LiteralBoolContext) GetRuleContext

func (s *LiteralBoolContext) GetRuleContext() antlr.RuleContext

func (*LiteralBoolContext) TRUE

func (s *LiteralBoolContext) TRUE() antlr.TerminalNode

type LiteralContext

type LiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLiteralContext

func NewEmptyLiteralContext() *LiteralContext

func NewLiteralContext

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

func (*LiteralContext) CopyAll

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

func (*LiteralContext) GetParser

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

func (*LiteralContext) GetRuleContext

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

func (*LiteralContext) IsLiteralContext

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) ToStringTree

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

type LiteralENumContext

type LiteralENumContext struct {
	LiteralContext
}

func NewLiteralENumContext

func NewLiteralENumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralENumContext

func (*LiteralENumContext) Accept

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

func (*LiteralENumContext) ENUM

func (s *LiteralENumContext) ENUM() antlr.TerminalNode

func (*LiteralENumContext) GetRuleContext

func (s *LiteralENumContext) GetRuleContext() antlr.RuleContext

type LiteralFloatContext

type LiteralFloatContext struct {
	LiteralContext
}

func NewLiteralFloatContext

func NewLiteralFloatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralFloatContext

func (*LiteralFloatContext) Accept

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

func (*LiteralFloatContext) FLOAT

func (s *LiteralFloatContext) FLOAT() antlr.TerminalNode

func (*LiteralFloatContext) GetRuleContext

func (s *LiteralFloatContext) GetRuleContext() antlr.RuleContext

type LiteralFuncContext

type LiteralFuncContext struct {
	LiteralContext
}

func NewLiteralFuncContext

func NewLiteralFuncContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralFuncContext

func (*LiteralFuncContext) Accept

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

func (*LiteralFuncContext) AllCOMMA

func (s *LiteralFuncContext) AllCOMMA() []antlr.TerminalNode

func (*LiteralFuncContext) AllIDENTIFIER

func (s *LiteralFuncContext) AllIDENTIFIER() []antlr.TerminalNode

func (*LiteralFuncContext) COMMA

func (s *LiteralFuncContext) COMMA(i int) antlr.TerminalNode

func (*LiteralFuncContext) CodeBlock

func (s *LiteralFuncContext) CodeBlock() ICodeBlockContext

func (*LiteralFuncContext) FUNC

func (s *LiteralFuncContext) FUNC() antlr.TerminalNode

func (*LiteralFuncContext) GetRuleContext

func (s *LiteralFuncContext) GetRuleContext() antlr.RuleContext

func (*LiteralFuncContext) IDENTIFIER

func (s *LiteralFuncContext) IDENTIFIER(i int) antlr.TerminalNode

func (*LiteralFuncContext) L_PAREN

func (s *LiteralFuncContext) L_PAREN() antlr.TerminalNode

func (*LiteralFuncContext) MORE_ARGS

func (s *LiteralFuncContext) MORE_ARGS() antlr.TerminalNode

func (*LiteralFuncContext) R_PAREN

func (s *LiteralFuncContext) R_PAREN() antlr.TerminalNode

type LiteralIntegerContext

type LiteralIntegerContext struct {
	LiteralContext
}

func NewLiteralIntegerContext

func NewLiteralIntegerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralIntegerContext

func (*LiteralIntegerContext) Accept

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

func (*LiteralIntegerContext) GetRuleContext

func (s *LiteralIntegerContext) GetRuleContext() antlr.RuleContext

func (*LiteralIntegerContext) Integer

func (s *LiteralIntegerContext) Integer() IIntegerContext

type LiteralLambdaBlockContext

type LiteralLambdaBlockContext struct {
	LiteralContext
}

func NewLiteralLambdaBlockContext

func NewLiteralLambdaBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralLambdaBlockContext

func (*LiteralLambdaBlockContext) ARROW

func (s *LiteralLambdaBlockContext) ARROW() antlr.TerminalNode

func (*LiteralLambdaBlockContext) Accept

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

func (*LiteralLambdaBlockContext) AllCOMMA

func (s *LiteralLambdaBlockContext) AllCOMMA() []antlr.TerminalNode

func (*LiteralLambdaBlockContext) AllIDENTIFIER

func (s *LiteralLambdaBlockContext) AllIDENTIFIER() []antlr.TerminalNode

func (*LiteralLambdaBlockContext) COMMA

func (s *LiteralLambdaBlockContext) COMMA(i int) antlr.TerminalNode

func (*LiteralLambdaBlockContext) CodeBlock

func (s *LiteralLambdaBlockContext) CodeBlock() ICodeBlockContext

func (*LiteralLambdaBlockContext) GetRuleContext

func (s *LiteralLambdaBlockContext) GetRuleContext() antlr.RuleContext

func (*LiteralLambdaBlockContext) IDENTIFIER

func (s *LiteralLambdaBlockContext) IDENTIFIER(i int) antlr.TerminalNode

func (*LiteralLambdaBlockContext) L_PAREN

func (s *LiteralLambdaBlockContext) L_PAREN() antlr.TerminalNode

func (*LiteralLambdaBlockContext) MORE_ARGS

func (s *LiteralLambdaBlockContext) MORE_ARGS() antlr.TerminalNode

func (*LiteralLambdaBlockContext) R_PAREN

func (s *LiteralLambdaBlockContext) R_PAREN() antlr.TerminalNode

type LiteralLambdaExprContext

type LiteralLambdaExprContext struct {
	LiteralContext
}

func NewLiteralLambdaExprContext

func NewLiteralLambdaExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralLambdaExprContext

func (*LiteralLambdaExprContext) ARROW

func (s *LiteralLambdaExprContext) ARROW() antlr.TerminalNode

func (*LiteralLambdaExprContext) Accept

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

func (*LiteralLambdaExprContext) AllCOMMA

func (s *LiteralLambdaExprContext) AllCOMMA() []antlr.TerminalNode

func (*LiteralLambdaExprContext) AllIDENTIFIER

func (s *LiteralLambdaExprContext) AllIDENTIFIER() []antlr.TerminalNode

func (*LiteralLambdaExprContext) COMMA

func (s *LiteralLambdaExprContext) COMMA(i int) antlr.TerminalNode

func (*LiteralLambdaExprContext) Expr

func (s *LiteralLambdaExprContext) Expr() IExprContext

func (*LiteralLambdaExprContext) GetRuleContext

func (s *LiteralLambdaExprContext) GetRuleContext() antlr.RuleContext

func (*LiteralLambdaExprContext) IDENTIFIER

func (s *LiteralLambdaExprContext) IDENTIFIER(i int) antlr.TerminalNode

func (*LiteralLambdaExprContext) L_PAREN

func (s *LiteralLambdaExprContext) L_PAREN() antlr.TerminalNode

func (*LiteralLambdaExprContext) MORE_ARGS

func (s *LiteralLambdaExprContext) MORE_ARGS() antlr.TerminalNode

func (*LiteralLambdaExprContext) R_PAREN

func (s *LiteralLambdaExprContext) R_PAREN() antlr.TerminalNode

type LiteralNilContext

type LiteralNilContext struct {
	LiteralContext
}

func NewLiteralNilContext

func NewLiteralNilContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralNilContext

func (*LiteralNilContext) Accept

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

func (*LiteralNilContext) GetRuleContext

func (s *LiteralNilContext) GetRuleContext() antlr.RuleContext

func (*LiteralNilContext) NIL

func (s *LiteralNilContext) NIL() antlr.TerminalNode

type LiteralObjectContext

type LiteralObjectContext struct {
	LiteralContext
}

func NewLiteralObjectContext

func NewLiteralObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralObjectContext

func (*LiteralObjectContext) Accept

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

func (*LiteralObjectContext) AllCOMMA

func (s *LiteralObjectContext) AllCOMMA() []antlr.TerminalNode

func (*LiteralObjectContext) AllObjItem

func (s *LiteralObjectContext) AllObjItem() []IObjItemContext

func (*LiteralObjectContext) COMMA

func (s *LiteralObjectContext) COMMA(i int) antlr.TerminalNode

func (*LiteralObjectContext) GetRuleContext

func (s *LiteralObjectContext) GetRuleContext() antlr.RuleContext

func (*LiteralObjectContext) L_CURLY

func (s *LiteralObjectContext) L_CURLY() antlr.TerminalNode

func (*LiteralObjectContext) ObjItem

func (s *LiteralObjectContext) ObjItem(i int) IObjItemContext

func (*LiteralObjectContext) R_CURLY

func (s *LiteralObjectContext) R_CURLY() antlr.TerminalNode

type LiteralStringContext

type LiteralStringContext struct {
	LiteralContext
}

func NewLiteralStringContext

func NewLiteralStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralStringContext

func (*LiteralStringContext) Accept

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

func (*LiteralStringContext) GetRuleContext

func (s *LiteralStringContext) GetRuleContext() antlr.RuleContext

func (*LiteralStringContext) StringLiteral

func (s *LiteralStringContext) StringLiteral() IStringLiteralContext

type LiteralUndefinedContext

type LiteralUndefinedContext struct {
	LiteralContext
}

func NewLiteralUndefinedContext

func NewLiteralUndefinedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralUndefinedContext

func (*LiteralUndefinedContext) Accept

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

func (*LiteralUndefinedContext) GetRuleContext

func (s *LiteralUndefinedContext) GetRuleContext() antlr.RuleContext

func (*LiteralUndefinedContext) UNDEFINED

func (s *LiteralUndefinedContext) UNDEFINED() antlr.TerminalNode

type LvalByFieldContext

type LvalByFieldContext struct {
	LvalContext
	// contains filtered or unexported fields
}

func NewLvalByFieldContext

func NewLvalByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByFieldContext

func (*LvalByFieldContext) Accept

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

func (*LvalByFieldContext) DOT

func (s *LvalByFieldContext) DOT() antlr.TerminalNode

func (*LvalByFieldContext) GetField

func (s *LvalByFieldContext) GetField() antlr.Token

func (*LvalByFieldContext) GetRuleContext

func (s *LvalByFieldContext) GetRuleContext() antlr.RuleContext

func (*LvalByFieldContext) IDENTIFIER

func (s *LvalByFieldContext) IDENTIFIER() antlr.TerminalNode

func (*LvalByFieldContext) Lval

func (s *LvalByFieldContext) Lval() ILvalContext

func (*LvalByFieldContext) SetField

func (s *LvalByFieldContext) SetField(v antlr.Token)

type LvalByIdContext

type LvalByIdContext struct {
	LvalContext
}

func NewLvalByIdContext

func NewLvalByIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByIdContext

func (*LvalByIdContext) Accept

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

func (*LvalByIdContext) GetRuleContext

func (s *LvalByIdContext) GetRuleContext() antlr.RuleContext

func (*LvalByIdContext) IDENTIFIER

func (s *LvalByIdContext) IDENTIFIER() antlr.TerminalNode

type LvalByIndexContext

type LvalByIndexContext struct {
	LvalContext
	// contains filtered or unexported fields
}

func NewLvalByIndexContext

func NewLvalByIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalByIndexContext

func (*LvalByIndexContext) Accept

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

func (*LvalByIndexContext) Expr

func (s *LvalByIndexContext) Expr() IExprContext

func (*LvalByIndexContext) GetIndex

func (s *LvalByIndexContext) GetIndex() IExprContext

func (*LvalByIndexContext) GetRuleContext

func (s *LvalByIndexContext) GetRuleContext() antlr.RuleContext

func (*LvalByIndexContext) L_BRACKET

func (s *LvalByIndexContext) L_BRACKET() antlr.TerminalNode

func (*LvalByIndexContext) Lval

func (s *LvalByIndexContext) Lval() ILvalContext

func (*LvalByIndexContext) R_BRACKET

func (s *LvalByIndexContext) R_BRACKET() antlr.TerminalNode

func (*LvalByIndexContext) SetIndex

func (s *LvalByIndexContext) SetIndex(v IExprContext)

type LvalContext

type LvalContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLvalContext

func NewEmptyLvalContext() *LvalContext

func NewLvalContext

func NewLvalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LvalContext

func (*LvalContext) CopyAll

func (s *LvalContext) CopyAll(ctx *LvalContext)

func (*LvalContext) GetParser

func (s *LvalContext) GetParser() antlr.Parser

func (*LvalContext) GetRuleContext

func (s *LvalContext) GetRuleContext() antlr.RuleContext

func (*LvalContext) IsLvalContext

func (*LvalContext) IsLvalContext()

func (*LvalContext) ToStringTree

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

type LvalItByFieldContext

type LvalItByFieldContext struct {
	LvalContext
	// contains filtered or unexported fields
}

func NewLvalItByFieldContext

func NewLvalItByFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LvalItByFieldContext

func (*LvalItByFieldContext) Accept

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

func (*LvalItByFieldContext) DOT

func (s *LvalItByFieldContext) DOT() antlr.TerminalNode

func (*LvalItByFieldContext) GetField

func (s *LvalItByFieldContext) GetField() antlr.Token

func (*LvalItByFieldContext) GetRuleContext

func (s *LvalItByFieldContext) GetRuleContext() antlr.RuleContext

func (*LvalItByFieldContext) IDENTIFIER

func (s *LvalItByFieldContext) IDENTIFIER() antlr.TerminalNode

func (*LvalItByFieldContext) SetField

func (s *LvalItByFieldContext) SetField(v antlr.Token)

type MemberDefContext

type MemberDefContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMemberDefContext

func NewEmptyMemberDefContext() *MemberDefContext

func NewMemberDefContext

func NewMemberDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberDefContext

func (*MemberDefContext) Accept

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

func (*MemberDefContext) GetParser

func (s *MemberDefContext) GetParser() antlr.Parser

func (*MemberDefContext) GetRuleContext

func (s *MemberDefContext) GetRuleContext() antlr.RuleContext

func (*MemberDefContext) IsMemberDefContext

func (*MemberDefContext) IsMemberDefContext()

func (*MemberDefContext) KeyValue

func (s *MemberDefContext) KeyValue() IKeyValueContext

func (*MemberDefContext) STATIC

func (s *MemberDefContext) STATIC() antlr.TerminalNode

func (*MemberDefContext) ToStringTree

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

type ModuleContext

type ModuleContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyModuleContext

func NewEmptyModuleContext() *ModuleContext

func NewModuleContext

func NewModuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleContext

func (*ModuleContext) Accept

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

func (*ModuleContext) Block

func (s *ModuleContext) Block() IBlockContext

func (*ModuleContext) GetParser

func (s *ModuleContext) GetParser() antlr.Parser

func (*ModuleContext) GetRuleContext

func (s *ModuleContext) GetRuleContext() antlr.RuleContext

func (*ModuleContext) IsModuleContext

func (*ModuleContext) IsModuleContext()

func (*ModuleContext) ToStringTree

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

type ObjItemContext

type ObjItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyObjItemContext

func NewEmptyObjItemContext() *ObjItemContext

func NewObjItemContext

func NewObjItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjItemContext

func (*ObjItemContext) CopyAll

func (s *ObjItemContext) CopyAll(ctx *ObjItemContext)

func (*ObjItemContext) GetParser

func (s *ObjItemContext) GetParser() antlr.Parser

func (*ObjItemContext) GetRuleContext

func (s *ObjItemContext) GetRuleContext() antlr.RuleContext

func (*ObjItemContext) IsObjItemContext

func (*ObjItemContext) IsObjItemContext()

func (*ObjItemContext) ToStringTree

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

type ObjItemExpandedContext

type ObjItemExpandedContext struct {
	ObjItemContext
}

func NewObjItemExpandedContext

func NewObjItemExpandedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjItemExpandedContext

func (*ObjItemExpandedContext) Accept

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

func (*ObjItemExpandedContext) Expr

func (s *ObjItemExpandedContext) Expr() IExprContext

func (*ObjItemExpandedContext) GetRuleContext

func (s *ObjItemExpandedContext) GetRuleContext() antlr.RuleContext

func (*ObjItemExpandedContext) MORE_ARGS

func (s *ObjItemExpandedContext) MORE_ARGS() antlr.TerminalNode

type ObjItemKVContext

type ObjItemKVContext struct {
	ObjItemContext
}

func NewObjItemKVContext

func NewObjItemKVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjItemKVContext

func (*ObjItemKVContext) Accept

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

func (*ObjItemKVContext) GetRuleContext

func (s *ObjItemKVContext) GetRuleContext() antlr.RuleContext

func (*ObjItemKVContext) KeyValue

func (s *ObjItemKVContext) KeyValue() IKeyValueContext

type ObjectComprehensionContext

type ObjectComprehensionContext struct {
	LiteralContext
	// contains filtered or unexported fields
}

func NewObjectComprehensionContext

func NewObjectComprehensionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectComprehensionContext

func (*ObjectComprehensionContext) Accept

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

func (*ObjectComprehensionContext) AllExpr

func (s *ObjectComprehensionContext) AllExpr() []IExprContext

func (*ObjectComprehensionContext) AllIDENTIFIER

func (s *ObjectComprehensionContext) AllIDENTIFIER() []antlr.TerminalNode

func (*ObjectComprehensionContext) COLON

func (s *ObjectComprehensionContext) COLON() antlr.TerminalNode

func (*ObjectComprehensionContext) COMMA

func (s *ObjectComprehensionContext) COMMA() antlr.TerminalNode

func (*ObjectComprehensionContext) Expr

func (s *ObjectComprehensionContext) Expr(i int) IExprContext

func (*ObjectComprehensionContext) FOR

func (s *ObjectComprehensionContext) FOR() antlr.TerminalNode

func (*ObjectComprehensionContext) GetBegin

func (s *ObjectComprehensionContext) GetBegin() IExprContext

func (*ObjectComprehensionContext) GetEnd

func (s *ObjectComprehensionContext) GetEnd() IExprContext

func (*ObjectComprehensionContext) GetFilter

func (s *ObjectComprehensionContext) GetFilter() IExprContext

func (*ObjectComprehensionContext) GetIndexer

func (s *ObjectComprehensionContext) GetIndexer() antlr.Token

func (*ObjectComprehensionContext) GetKeyExpr

func (s *ObjectComprehensionContext) GetKeyExpr() IExprContext

func (*ObjectComprehensionContext) GetRuleContext

func (s *ObjectComprehensionContext) GetRuleContext() antlr.RuleContext

func (*ObjectComprehensionContext) GetValue

func (s *ObjectComprehensionContext) GetValue() antlr.Token

func (*ObjectComprehensionContext) GetValueExpr

func (s *ObjectComprehensionContext) GetValueExpr() IExprContext

func (*ObjectComprehensionContext) IDENTIFIER

func (s *ObjectComprehensionContext) IDENTIFIER(i int) antlr.TerminalNode

func (*ObjectComprehensionContext) IF

func (s *ObjectComprehensionContext) IF() antlr.TerminalNode

func (*ObjectComprehensionContext) IN

func (s *ObjectComprehensionContext) IN() antlr.TerminalNode

func (*ObjectComprehensionContext) L_CURLY

func (s *ObjectComprehensionContext) L_CURLY() antlr.TerminalNode

func (*ObjectComprehensionContext) RANGE_WITHOUT_END

func (s *ObjectComprehensionContext) RANGE_WITHOUT_END() antlr.TerminalNode

func (*ObjectComprehensionContext) RANGE_WITH_END

func (s *ObjectComprehensionContext) RANGE_WITH_END() antlr.TerminalNode

func (*ObjectComprehensionContext) R_CURLY

func (s *ObjectComprehensionContext) R_CURLY() antlr.TerminalNode

func (*ObjectComprehensionContext) SetBegin

func (s *ObjectComprehensionContext) SetBegin(v IExprContext)

func (*ObjectComprehensionContext) SetEnd

func (s *ObjectComprehensionContext) SetEnd(v IExprContext)

func (*ObjectComprehensionContext) SetFilter

func (s *ObjectComprehensionContext) SetFilter(v IExprContext)

func (*ObjectComprehensionContext) SetIndexer

func (s *ObjectComprehensionContext) SetIndexer(v antlr.Token)

func (*ObjectComprehensionContext) SetKeyExpr

func (s *ObjectComprehensionContext) SetKeyExpr(v IExprContext)

func (*ObjectComprehensionContext) SetValue

func (s *ObjectComprehensionContext) SetValue(v antlr.Token)

func (*ObjectComprehensionContext) SetValueExpr

func (s *ObjectComprehensionContext) SetValueExpr(v IExprContext)

type ParseVisitor

type ParseVisitor struct {
	BaseZggParserVisitor
	FileName string
}

func (*ParseVisitor) Init

func (v *ParseVisitor) Init()

func (*ParseVisitor) VisitArguments

func (v *ParseVisitor) VisitArguments(ctx *ArgumentsContext) interface{}

func (*ParseVisitor) VisitArrayComprehension

func (v *ParseVisitor) VisitArrayComprehension(ctx *ArrayComprehensionContext) interface{}

func (*ParseVisitor) VisitArrayItem

func (v *ParseVisitor) VisitArrayItem(ctx *ArrayItemContext) interface{}

func (*ParseVisitor) VisitAssignExists

func (v *ParseVisitor) VisitAssignExists(ctx *AssignExistsContext) interface{}

func (*ParseVisitor) VisitAssignNew

func (v *ParseVisitor) VisitAssignNew(ctx *AssignNewContext) interface{}

func (*ParseVisitor) VisitAssignNewDeArray

func (v *ParseVisitor) VisitAssignNewDeArray(ctx *AssignNewDeArrayContext) interface{}

func (*ParseVisitor) VisitAssignNewDeObject

func (v *ParseVisitor) VisitAssignNewDeObject(ctx *AssignNewDeObjectContext) interface{}

func (*ParseVisitor) VisitAssignNewLocal

func (v *ParseVisitor) VisitAssignNewLocal(ctx *AssignNewLocalContext) interface{}

func (*ParseVisitor) VisitBlock

func (v *ParseVisitor) VisitBlock(ctx *BlockContext) interface{}

func (*ParseVisitor) VisitCallStmt

func (v *ParseVisitor) VisitCallStmt(ctx *CallStmtContext) interface{}

func (*ParseVisitor) VisitCodeBlock

func (v *ParseVisitor) VisitCodeBlock(ctx *CodeBlockContext) interface{}

func (*ParseVisitor) VisitExprAssertError

func (v *ParseVisitor) VisitExprAssertError(ctx *ExprAssertErrorContext) interface{}

func (*ParseVisitor) VisitExprAssign

func (v *ParseVisitor) VisitExprAssign(ctx *ExprAssignContext) interface{}

func (*ParseVisitor) VisitExprBitAnd

func (v *ParseVisitor) VisitExprBitAnd(ctx *ExprBitAndContext) interface{}

func (*ParseVisitor) VisitExprBitNot

func (v *ParseVisitor) VisitExprBitNot(ctx *ExprBitNotContext) interface{}

func (*ParseVisitor) VisitExprBitOr

func (v *ParseVisitor) VisitExprBitOr(ctx *ExprBitOrContext) interface{}

func (*ParseVisitor) VisitExprBitShift

func (v *ParseVisitor) VisitExprBitShift(ctx *ExprBitShiftContext) interface{}

func (*ParseVisitor) VisitExprBitXor

func (v *ParseVisitor) VisitExprBitXor(ctx *ExprBitXorContext) interface{}

func (*ParseVisitor) VisitExprByField

func (v *ParseVisitor) VisitExprByField(ctx *ExprByFieldContext) interface{}

func (*ParseVisitor) VisitExprByIndex

func (v *ParseVisitor) VisitExprByIndex(ctx *ExprByIndexContext) interface{}

func (*ParseVisitor) VisitExprBySlice

func (v *ParseVisitor) VisitExprBySlice(ctx *ExprBySliceContext) interface{}

func (*ParseVisitor) VisitExprCall

func (v *ParseVisitor) VisitExprCall(ctx *ExprCallContext) interface{}

func (*ParseVisitor) VisitExprCompare

func (v *ParseVisitor) VisitExprCompare(ctx *ExprCompareContext) interface{}

func (*ParseVisitor) VisitExprFallback

func (v *ParseVisitor) VisitExprFallback(ctx *ExprFallbackContext) interface{}

func (*ParseVisitor) VisitExprIdentifier

func (v *ParseVisitor) VisitExprIdentifier(ctx *ExprIdentifierContext) interface{}

func (*ParseVisitor) VisitExprInContainer

func (v *ParseVisitor) VisitExprInContainer(ctx *ExprInContainerContext) interface{}

func (*ParseVisitor) VisitExprInRange

func (v *ParseVisitor) VisitExprInRange(ctx *ExprInRangeContext) interface{}

func (*ParseVisitor) VisitExprIsType

func (v *ParseVisitor) VisitExprIsType(ctx *ExprIsTypeContext) interface{}

func (*ParseVisitor) VisitExprItByField

func (v *ParseVisitor) VisitExprItByField(ctx *ExprItByFieldContext) interface{}

func (*ParseVisitor) VisitExprLiteral

func (v *ParseVisitor) VisitExprLiteral(ctx *ExprLiteralContext) interface{}

func (*ParseVisitor) VisitExprLogicAnd

func (v *ParseVisitor) VisitExprLogicAnd(ctx *ExprLogicAndContext) interface{}

func (*ParseVisitor) VisitExprLogicNot

func (v *ParseVisitor) VisitExprLogicNot(ctx *ExprLogicNotContext) interface{}

func (*ParseVisitor) VisitExprLogicOr

func (v *ParseVisitor) VisitExprLogicOr(ctx *ExprLogicOrContext) interface{}

func (*ParseVisitor) VisitExprNegative

func (v *ParseVisitor) VisitExprNegative(ctx *ExprNegativeContext) interface{}

func (*ParseVisitor) VisitExprPlusMinus

func (v *ParseVisitor) VisitExprPlusMinus(ctx *ExprPlusMinusContext) interface{}

func (*ParseVisitor) VisitExprPostIncDec

func (v *ParseVisitor) VisitExprPostIncDec(ctx *ExprPostIncDecContext) interface{}

func (*ParseVisitor) VisitExprPow

func (v *ParseVisitor) VisitExprPow(ctx *ExprPowContext) interface{}

func (*ParseVisitor) VisitExprPreIncDec

func (v *ParseVisitor) VisitExprPreIncDec(ctx *ExprPreIncDecContext) interface{}

func (*ParseVisitor) VisitExprQuestion

func (v *ParseVisitor) VisitExprQuestion(ctx *ExprQuestionContext) interface{}

func (*ParseVisitor) VisitExprShortImport

func (v *ParseVisitor) VisitExprShortImport(ctx *ExprShortImportContext) interface{}

func (*ParseVisitor) VisitExprSub

func (v *ParseVisitor) VisitExprSub(ctx *ExprSubContext) interface{}

func (*ParseVisitor) VisitExprTimesDivMod

func (v *ParseVisitor) VisitExprTimesDivMod(ctx *ExprTimesDivModContext) interface{}

func (*ParseVisitor) VisitExprUseBlock

func (v *ParseVisitor) VisitExprUseBlock(ctx *ExprUseBlockContext) interface{}

func (*ParseVisitor) VisitExprUseCloser

func (v *ParseVisitor) VisitExprUseCloser(ctx *ExprUseCloserContext) interface{}

func (*ParseVisitor) VisitExprUseMethod

func (v *ParseVisitor) VisitExprUseMethod(ctx *ExprUseMethodContext) interface{}

func (*ParseVisitor) VisitExprWhen

func (v *ParseVisitor) VisitExprWhen(ctx *ExprWhenContext) interface{}

func (*ParseVisitor) VisitExprWhenValue

func (v *ParseVisitor) VisitExprWhenValue(ctx *ExprWhenValueContext) interface{}

func (*ParseVisitor) VisitFuncArgument

func (v *ParseVisitor) VisitFuncArgument(ctx *FuncArgumentContext) interface{}

func (*ParseVisitor) VisitIfCondition

func (v *ParseVisitor) VisitIfCondition(ctx *IfConditionContext) interface{}

func (*ParseVisitor) VisitIntegerBin

func (v *ParseVisitor) VisitIntegerBin(ctx *IntegerBinContext) interface{}

func (*ParseVisitor) VisitIntegerDec

func (v *ParseVisitor) VisitIntegerDec(ctx *IntegerDecContext) interface{}

func (*ParseVisitor) VisitIntegerHex

func (v *ParseVisitor) VisitIntegerHex(ctx *IntegerHexContext) interface{}

func (*ParseVisitor) VisitIntegerOct

func (v *ParseVisitor) VisitIntegerOct(ctx *IntegerOctContext) interface{}

func (*ParseVisitor) VisitIntegerZero

func (v *ParseVisitor) VisitIntegerZero(ctx *IntegerZeroContext) interface{}

func (*ParseVisitor) VisitKVExprKey

func (v *ParseVisitor) VisitKVExprKey(ctx *KVExprKeyContext) interface{}

func (*ParseVisitor) VisitKVExprOnly

func (v *ParseVisitor) VisitKVExprOnly(ctx *KVExprOnlyContext) interface{}

func (*ParseVisitor) VisitKVIdKey

func (v *ParseVisitor) VisitKVIdKey(ctx *KVIdKeyContext) interface{}

func (*ParseVisitor) VisitKVIdOnly

func (v *ParseVisitor) VisitKVIdOnly(ctx *KVIdOnlyContext) interface{}

func (*ParseVisitor) VisitKVKeyFunc

func (v *ParseVisitor) VisitKVKeyFunc(ctx *KVKeyFuncContext) interface{}

func (*ParseVisitor) VisitKVStrKey

func (v *ParseVisitor) VisitKVStrKey(ctx *KVStrKeyContext) interface{}

func (*ParseVisitor) VisitLiteralArray

func (v *ParseVisitor) VisitLiteralArray(ctx *LiteralArrayContext) interface{}

func (*ParseVisitor) VisitLiteralBigNum

func (v *ParseVisitor) VisitLiteralBigNum(ctx *LiteralBigNumContext) interface{}

func (*ParseVisitor) VisitLiteralBool

func (v *ParseVisitor) VisitLiteralBool(ctx *LiteralBoolContext) interface{}

func (*ParseVisitor) VisitLiteralENum

func (v *ParseVisitor) VisitLiteralENum(ctx *LiteralENumContext) interface{}

func (*ParseVisitor) VisitLiteralFloat

func (v *ParseVisitor) VisitLiteralFloat(ctx *LiteralFloatContext) interface{}

func (*ParseVisitor) VisitLiteralFunc

func (v *ParseVisitor) VisitLiteralFunc(ctx *LiteralFuncContext) interface{}

func (*ParseVisitor) VisitLiteralInteger

func (v *ParseVisitor) VisitLiteralInteger(ctx *LiteralIntegerContext) interface{}

func (*ParseVisitor) VisitLiteralLambdaBlock

func (v *ParseVisitor) VisitLiteralLambdaBlock(ctx *LiteralLambdaBlockContext) interface{}

func (*ParseVisitor) VisitLiteralLambdaExpr

func (v *ParseVisitor) VisitLiteralLambdaExpr(ctx *LiteralLambdaExprContext) interface{}

func (*ParseVisitor) VisitLiteralNil

func (v *ParseVisitor) VisitLiteralNil(ctx *LiteralNilContext) interface{}

func (*ParseVisitor) VisitLiteralObject

func (v *ParseVisitor) VisitLiteralObject(ctx *LiteralObjectContext) interface{}

func (*ParseVisitor) VisitLiteralString

func (v *ParseVisitor) VisitLiteralString(ctx *LiteralStringContext) interface{}

func (*ParseVisitor) VisitLiteralUndefined

func (v *ParseVisitor) VisitLiteralUndefined(ctx *LiteralUndefinedContext) interface{}

func (*ParseVisitor) VisitLvalByField

func (v *ParseVisitor) VisitLvalByField(ctx *LvalByFieldContext) interface{}

func (*ParseVisitor) VisitLvalById

func (v *ParseVisitor) VisitLvalById(ctx *LvalByIdContext) interface{}

func (*ParseVisitor) VisitLvalByIndex

func (v *ParseVisitor) VisitLvalByIndex(ctx *LvalByIndexContext) interface{}

func (*ParseVisitor) VisitLvalItByField

func (v *ParseVisitor) VisitLvalItByField(ctx *LvalItByFieldContext) interface{}

func (*ParseVisitor) VisitMemberDef

func (v *ParseVisitor) VisitMemberDef(ctx *MemberDefContext) interface{}

func (*ParseVisitor) VisitModule

func (v *ParseVisitor) VisitModule(ctx *ModuleContext) interface{}

func (*ParseVisitor) VisitObjItemExpanded

func (v *ParseVisitor) VisitObjItemExpanded(ctx *ObjItemExpandedContext) interface{}

func (*ParseVisitor) VisitObjItemKV

func (v *ParseVisitor) VisitObjItemKV(ctx *ObjItemKVContext) interface{}

func (*ParseVisitor) VisitObjectComprehension

func (v *ParseVisitor) VisitObjectComprehension(ctx *ObjectComprehensionContext) interface{}

func (*ParseVisitor) VisitPostIncDec

func (v *ParseVisitor) VisitPostIncDec(ctx *PostIncDecContext) interface{}

func (*ParseVisitor) VisitPreIncDec

func (v *ParseVisitor) VisitPreIncDec(ctx *PreIncDecContext) interface{}

func (*ParseVisitor) VisitReplBlock

func (v *ParseVisitor) VisitReplBlock(ctx *ReplBlockContext) interface{}

func (*ParseVisitor) VisitReplExpr

func (v *ParseVisitor) VisitReplExpr(ctx *ReplExprContext) interface{}

func (*ParseVisitor) VisitStmtAssert

func (v *ParseVisitor) VisitStmtAssert(ctx *StmtAssertContext) interface{}

func (*ParseVisitor) VisitStmtAssign

func (v *ParseVisitor) VisitStmtAssign(ctx *StmtAssignContext) interface{}

func (*ParseVisitor) VisitStmtBlock

func (v *ParseVisitor) VisitStmtBlock(ctx *StmtBlockContext) interface{}

func (*ParseVisitor) VisitStmtBreak

func (v *ParseVisitor) VisitStmtBreak(ctx *StmtBreakContext) interface{}

func (*ParseVisitor) VisitStmtClassDefine

func (v *ParseVisitor) VisitStmtClassDefine(ctx *StmtClassDefineContext) interface{}

func (*ParseVisitor) VisitStmtContinue

func (v *ParseVisitor) VisitStmtContinue(ctx *StmtContinueContext) interface{}

func (*ParseVisitor) VisitStmtDefer

func (v *ParseVisitor) VisitStmtDefer(ctx *StmtDeferContext) interface{}

func (*ParseVisitor) VisitStmtDeferBlock

func (v *ParseVisitor) VisitStmtDeferBlock(ctx *StmtDeferBlockContext) interface{}

func (*ParseVisitor) VisitStmtDoWhile

func (v *ParseVisitor) VisitStmtDoWhile(ctx *StmtDoWhileContext) interface{}

func (*ParseVisitor) VisitStmtExportExpr

func (v *ParseVisitor) VisitStmtExportExpr(ctx *StmtExportExprContext) interface{}

func (*ParseVisitor) VisitStmtExportFuncDefine

func (v *ParseVisitor) VisitStmtExportFuncDefine(ctx *StmtExportFuncDefineContext) interface{}

func (*ParseVisitor) VisitStmtExportIdentifier

func (v *ParseVisitor) VisitStmtExportIdentifier(ctx *StmtExportIdentifierContext) interface{}

func (*ParseVisitor) VisitStmtExtend

func (v *ParseVisitor) VisitStmtExtend(ctx *StmtExtendContext) interface{}

func (*ParseVisitor) VisitStmtFor

func (v *ParseVisitor) VisitStmtFor(ctx *StmtForContext) interface{}

func (*ParseVisitor) VisitStmtForEach

func (v *ParseVisitor) VisitStmtForEach(ctx *StmtForEachContext) interface{}

func (*ParseVisitor) VisitStmtFuncCall

func (v *ParseVisitor) VisitStmtFuncCall(ctx *StmtFuncCallContext) interface{}

func (*ParseVisitor) VisitStmtFuncDefine

func (v *ParseVisitor) VisitStmtFuncDefine(ctx *StmtFuncDefineContext) interface{}

func (*ParseVisitor) VisitStmtIf

func (v *ParseVisitor) VisitStmtIf(ctx *StmtIfContext) interface{}

func (*ParseVisitor) VisitStmtPostIncDec

func (v *ParseVisitor) VisitStmtPostIncDec(ctx *StmtPostIncDecContext) interface{}

func (*ParseVisitor) VisitStmtPreIncDec

func (v *ParseVisitor) VisitStmtPreIncDec(ctx *StmtPreIncDecContext) interface{}

func (*ParseVisitor) VisitStmtReturn

func (v *ParseVisitor) VisitStmtReturn(ctx *StmtReturnContext) interface{}

func (*ParseVisitor) VisitStmtReturnNone

func (v *ParseVisitor) VisitStmtReturnNone(ctx *StmtReturnNoneContext) interface{}

func (*ParseVisitor) VisitStmtSwitch

func (v *ParseVisitor) VisitStmtSwitch(ctx *StmtSwitchContext) interface{}

func (*ParseVisitor) VisitStmtTry

func (v *ParseVisitor) VisitStmtTry(ctx *StmtTryContext) interface{}

func (*ParseVisitor) VisitStmtWhile

func (v *ParseVisitor) VisitStmtWhile(ctx *StmtWhileContext) interface{}

func (*ParseVisitor) VisitStringLiteral

func (v *ParseVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

func (*ParseVisitor) VisitTemplateString

func (v *ParseVisitor) VisitTemplateString(ctx *TemplateStringContext) interface{}

func (*ParseVisitor) VisitTsExpr

func (v *ParseVisitor) VisitTsExpr(ctx *TsExprContext) interface{}

func (*ParseVisitor) VisitTsIdentifier

func (v *ParseVisitor) VisitTsIdentifier(ctx *TsIdentifierContext) interface{}

func (*ParseVisitor) VisitTsRaw

func (v *ParseVisitor) VisitTsRaw(ctx *TsRawContext) interface{}

func (*ParseVisitor) VisitWhenConditionInList

func (v *ParseVisitor) VisitWhenConditionInList(ctx *WhenConditionInListContext) interface{}

func (*ParseVisitor) VisitWhenConditionInRange

func (v *ParseVisitor) VisitWhenConditionInRange(ctx *WhenConditionInRangeContext) interface{}

func (*ParseVisitor) VisitWhenConditionIsType

func (v *ParseVisitor) VisitWhenConditionIsType(ctx *WhenConditionIsTypeContext) interface{}

type PostIncDecContext

type PostIncDecContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPostIncDecContext

func NewEmptyPostIncDecContext() *PostIncDecContext

func NewPostIncDecContext

func NewPostIncDecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostIncDecContext

func (*PostIncDecContext) Accept

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

func (*PostIncDecContext) GetOp

func (s *PostIncDecContext) GetOp() antlr.Token

func (*PostIncDecContext) GetParser

func (s *PostIncDecContext) GetParser() antlr.Parser

func (*PostIncDecContext) GetRuleContext

func (s *PostIncDecContext) GetRuleContext() antlr.RuleContext

func (*PostIncDecContext) IsPostIncDecContext

func (*PostIncDecContext) IsPostIncDecContext()

func (*PostIncDecContext) Lval

func (s *PostIncDecContext) Lval() ILvalContext

func (*PostIncDecContext) MINUS_MINUS

func (s *PostIncDecContext) MINUS_MINUS() antlr.TerminalNode

func (*PostIncDecContext) PLUS_PLUS

func (s *PostIncDecContext) PLUS_PLUS() antlr.TerminalNode

func (*PostIncDecContext) SetOp

func (s *PostIncDecContext) SetOp(v antlr.Token)

func (*PostIncDecContext) ToStringTree

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

type PreIncDecContext

type PreIncDecContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPreIncDecContext

func NewEmptyPreIncDecContext() *PreIncDecContext

func NewPreIncDecContext

func NewPreIncDecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreIncDecContext

func (*PreIncDecContext) Accept

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

func (*PreIncDecContext) GetOp

func (s *PreIncDecContext) GetOp() antlr.Token

func (*PreIncDecContext) GetParser

func (s *PreIncDecContext) GetParser() antlr.Parser

func (*PreIncDecContext) GetRuleContext

func (s *PreIncDecContext) GetRuleContext() antlr.RuleContext

func (*PreIncDecContext) IsPreIncDecContext

func (*PreIncDecContext) IsPreIncDecContext()

func (*PreIncDecContext) Lval

func (s *PreIncDecContext) Lval() ILvalContext

func (*PreIncDecContext) MINUS_MINUS

func (s *PreIncDecContext) MINUS_MINUS() antlr.TerminalNode

func (*PreIncDecContext) PLUS_PLUS

func (s *PreIncDecContext) PLUS_PLUS() antlr.TerminalNode

func (*PreIncDecContext) SetOp

func (s *PreIncDecContext) SetOp(v antlr.Token)

func (*PreIncDecContext) ToStringTree

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

type ReplBlockContext

type ReplBlockContext struct {
	ReplItemContext
}

func NewReplBlockContext

func NewReplBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplBlockContext

func (*ReplBlockContext) Accept

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

func (*ReplBlockContext) Block

func (s *ReplBlockContext) Block() IBlockContext

func (*ReplBlockContext) GetRuleContext

func (s *ReplBlockContext) GetRuleContext() antlr.RuleContext

type ReplExprContext

type ReplExprContext struct {
	ReplItemContext
}

func NewReplExprContext

func NewReplExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplExprContext

func (*ReplExprContext) Accept

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

func (*ReplExprContext) Expr

func (s *ReplExprContext) Expr() IExprContext

func (*ReplExprContext) GetRuleContext

func (s *ReplExprContext) GetRuleContext() antlr.RuleContext

type ReplItemContext

type ReplItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReplItemContext

func NewEmptyReplItemContext() *ReplItemContext

func NewReplItemContext

func NewReplItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplItemContext

func (*ReplItemContext) CopyAll

func (s *ReplItemContext) CopyAll(ctx *ReplItemContext)

func (*ReplItemContext) GetParser

func (s *ReplItemContext) GetParser() antlr.Parser

func (*ReplItemContext) GetRuleContext

func (s *ReplItemContext) GetRuleContext() antlr.RuleContext

func (*ReplItemContext) IsReplItemContext

func (*ReplItemContext) IsReplItemContext()

func (*ReplItemContext) ToStringTree

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

type StmtAssertContext

type StmtAssertContext struct {
	StmtContext
}

func NewStmtAssertContext

func NewStmtAssertContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtAssertContext

func (*StmtAssertContext) ASSERT

func (s *StmtAssertContext) ASSERT() antlr.TerminalNode

func (*StmtAssertContext) Accept

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

func (*StmtAssertContext) AllExpr

func (s *StmtAssertContext) AllExpr() []IExprContext

func (*StmtAssertContext) COMMA

func (s *StmtAssertContext) COMMA() antlr.TerminalNode

func (*StmtAssertContext) Expr

func (s *StmtAssertContext) Expr(i int) IExprContext

func (*StmtAssertContext) GetRuleContext

func (s *StmtAssertContext) GetRuleContext() antlr.RuleContext

type StmtAssignContext

type StmtAssignContext struct {
	StmtContext
}

func NewStmtAssignContext

func NewStmtAssignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtAssignContext

func (*StmtAssignContext) Accept

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

func (*StmtAssignContext) AssignExpr

func (s *StmtAssignContext) AssignExpr() IAssignExprContext

func (*StmtAssignContext) GetRuleContext

func (s *StmtAssignContext) GetRuleContext() antlr.RuleContext

type StmtBlockContext

type StmtBlockContext struct {
	StmtContext
}

func NewStmtBlockContext

func NewStmtBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtBlockContext

func (*StmtBlockContext) Accept

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

func (*StmtBlockContext) CodeBlock

func (s *StmtBlockContext) CodeBlock() ICodeBlockContext

func (*StmtBlockContext) GetRuleContext

func (s *StmtBlockContext) GetRuleContext() antlr.RuleContext

type StmtBreakContext

type StmtBreakContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtBreakContext

func NewStmtBreakContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtBreakContext

func (*StmtBreakContext) Accept

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

func (*StmtBreakContext) BREAK

func (s *StmtBreakContext) BREAK() antlr.TerminalNode

func (*StmtBreakContext) GetLabel

func (s *StmtBreakContext) GetLabel() antlr.Token

func (*StmtBreakContext) GetRuleContext

func (s *StmtBreakContext) GetRuleContext() antlr.RuleContext

func (*StmtBreakContext) IDENTIFIER

func (s *StmtBreakContext) IDENTIFIER() antlr.TerminalNode

func (*StmtBreakContext) SetLabel

func (s *StmtBreakContext) SetLabel(v antlr.Token)

type StmtClassDefineContext

type StmtClassDefineContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtClassDefineContext

func NewStmtClassDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtClassDefineContext

func (*StmtClassDefineContext) Accept

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

func (*StmtClassDefineContext) AllExpr

func (s *StmtClassDefineContext) AllExpr() []IExprContext

func (*StmtClassDefineContext) AllMemberDef

func (s *StmtClassDefineContext) AllMemberDef() []IMemberDefContext

func (*StmtClassDefineContext) CLASS

func (s *StmtClassDefineContext) CLASS() antlr.TerminalNode

func (*StmtClassDefineContext) COMMA

func (s *StmtClassDefineContext) COMMA() antlr.TerminalNode

func (*StmtClassDefineContext) EXPORT

func (s *StmtClassDefineContext) EXPORT() antlr.TerminalNode

func (*StmtClassDefineContext) Expr

func (s *StmtClassDefineContext) Expr(i int) IExprContext

func (*StmtClassDefineContext) GetBaseCls

func (s *StmtClassDefineContext) GetBaseCls() []IExprContext

func (*StmtClassDefineContext) GetClassName

func (s *StmtClassDefineContext) GetClassName() antlr.Token

func (*StmtClassDefineContext) GetRuleContext

func (s *StmtClassDefineContext) GetRuleContext() antlr.RuleContext

func (*StmtClassDefineContext) Get_expr

func (s *StmtClassDefineContext) Get_expr() IExprContext

func (*StmtClassDefineContext) IDENTIFIER

func (s *StmtClassDefineContext) IDENTIFIER() antlr.TerminalNode

func (*StmtClassDefineContext) L_CURLY

func (s *StmtClassDefineContext) L_CURLY() antlr.TerminalNode

func (*StmtClassDefineContext) L_PAREN

func (s *StmtClassDefineContext) L_PAREN() antlr.TerminalNode

func (*StmtClassDefineContext) MemberDef

func (s *StmtClassDefineContext) MemberDef(i int) IMemberDefContext

func (*StmtClassDefineContext) R_CURLY

func (s *StmtClassDefineContext) R_CURLY() antlr.TerminalNode

func (*StmtClassDefineContext) R_PAREN

func (s *StmtClassDefineContext) R_PAREN() antlr.TerminalNode

func (*StmtClassDefineContext) SetBaseCls

func (s *StmtClassDefineContext) SetBaseCls(v []IExprContext)

func (*StmtClassDefineContext) SetClassName

func (s *StmtClassDefineContext) SetClassName(v antlr.Token)

func (*StmtClassDefineContext) Set_expr

func (s *StmtClassDefineContext) Set_expr(v IExprContext)

type StmtContext

type StmtContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStmtContext

func NewEmptyStmtContext() *StmtContext

func NewStmtContext

func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext

func (*StmtContext) CopyAll

func (s *StmtContext) CopyAll(ctx *StmtContext)

func (*StmtContext) GetParser

func (s *StmtContext) GetParser() antlr.Parser

func (*StmtContext) GetRuleContext

func (s *StmtContext) GetRuleContext() antlr.RuleContext

func (*StmtContext) IsStmtContext

func (*StmtContext) IsStmtContext()

func (*StmtContext) ToStringTree

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

type StmtContinueContext

type StmtContinueContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtContinueContext

func NewStmtContinueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtContinueContext

func (*StmtContinueContext) Accept

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

func (*StmtContinueContext) CONTINUE

func (s *StmtContinueContext) CONTINUE() antlr.TerminalNode

func (*StmtContinueContext) GetLabel

func (s *StmtContinueContext) GetLabel() antlr.Token

func (*StmtContinueContext) GetRuleContext

func (s *StmtContinueContext) GetRuleContext() antlr.RuleContext

func (*StmtContinueContext) IDENTIFIER

func (s *StmtContinueContext) IDENTIFIER() antlr.TerminalNode

func (*StmtContinueContext) SetLabel

func (s *StmtContinueContext) SetLabel(v antlr.Token)

type StmtDeferBlockContext

type StmtDeferBlockContext struct {
	StmtContext
}

func NewStmtDeferBlockContext

func NewStmtDeferBlockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDeferBlockContext

func (*StmtDeferBlockContext) Accept

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

func (*StmtDeferBlockContext) BLOCK_DEFER

func (s *StmtDeferBlockContext) BLOCK_DEFER() antlr.TerminalNode

func (*StmtDeferBlockContext) CodeBlock

func (s *StmtDeferBlockContext) CodeBlock() ICodeBlockContext

func (*StmtDeferBlockContext) DEFER

func (s *StmtDeferBlockContext) DEFER() antlr.TerminalNode

func (*StmtDeferBlockContext) GetRuleContext

func (s *StmtDeferBlockContext) GetRuleContext() antlr.RuleContext

type StmtDeferContext

type StmtDeferContext struct {
	StmtContext
}

func NewStmtDeferContext

func NewStmtDeferContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDeferContext

func (*StmtDeferContext) Accept

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

func (*StmtDeferContext) Arguments

func (s *StmtDeferContext) Arguments() IArgumentsContext

func (*StmtDeferContext) BLOCK_DEFER

func (s *StmtDeferContext) BLOCK_DEFER() antlr.TerminalNode

func (*StmtDeferContext) DEFER

func (s *StmtDeferContext) DEFER() antlr.TerminalNode

func (*StmtDeferContext) Expr

func (s *StmtDeferContext) Expr() IExprContext

func (*StmtDeferContext) GetRuleContext

func (s *StmtDeferContext) GetRuleContext() antlr.RuleContext

func (*StmtDeferContext) OPTIONAL_CALL

func (s *StmtDeferContext) OPTIONAL_CALL() antlr.TerminalNode

type StmtDoWhileContext

type StmtDoWhileContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtDoWhileContext

func NewStmtDoWhileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtDoWhileContext

func (*StmtDoWhileContext) Accept

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

func (*StmtDoWhileContext) COLON

func (s *StmtDoWhileContext) COLON() antlr.TerminalNode

func (*StmtDoWhileContext) CodeBlock

func (s *StmtDoWhileContext) CodeBlock() ICodeBlockContext

func (*StmtDoWhileContext) DO

func (s *StmtDoWhileContext) DO() antlr.TerminalNode

func (*StmtDoWhileContext) Expr

func (s *StmtDoWhileContext) Expr() IExprContext

func (*StmtDoWhileContext) GetCheckExpr

func (s *StmtDoWhileContext) GetCheckExpr() IExprContext

func (*StmtDoWhileContext) GetExecBlock

func (s *StmtDoWhileContext) GetExecBlock() ICodeBlockContext

func (*StmtDoWhileContext) GetLabel

func (s *StmtDoWhileContext) GetLabel() antlr.Token

func (*StmtDoWhileContext) GetRuleContext

func (s *StmtDoWhileContext) GetRuleContext() antlr.RuleContext

func (*StmtDoWhileContext) IDENTIFIER

func (s *StmtDoWhileContext) IDENTIFIER() antlr.TerminalNode

func (*StmtDoWhileContext) SetCheckExpr

func (s *StmtDoWhileContext) SetCheckExpr(v IExprContext)

func (*StmtDoWhileContext) SetExecBlock

func (s *StmtDoWhileContext) SetExecBlock(v ICodeBlockContext)

func (*StmtDoWhileContext) SetLabel

func (s *StmtDoWhileContext) SetLabel(v antlr.Token)

func (*StmtDoWhileContext) WHILE

func (s *StmtDoWhileContext) WHILE() antlr.TerminalNode

type StmtExportExprContext

type StmtExportExprContext struct {
	StmtContext
}

func NewStmtExportExprContext

func NewStmtExportExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportExprContext

func (*StmtExportExprContext) Accept

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

func (*StmtExportExprContext) EXPORT

func (s *StmtExportExprContext) EXPORT() antlr.TerminalNode

func (*StmtExportExprContext) Expr

func (s *StmtExportExprContext) Expr() IExprContext

func (*StmtExportExprContext) GetRuleContext

func (s *StmtExportExprContext) GetRuleContext() antlr.RuleContext

func (*StmtExportExprContext) IDENTIFIER

func (s *StmtExportExprContext) IDENTIFIER() antlr.TerminalNode

func (*StmtExportExprContext) LOCAL_ASSIGN

func (s *StmtExportExprContext) LOCAL_ASSIGN() antlr.TerminalNode

type StmtExportFuncDefineContext

type StmtExportFuncDefineContext struct {
	StmtContext
}

func NewStmtExportFuncDefineContext

func NewStmtExportFuncDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportFuncDefineContext

func (*StmtExportFuncDefineContext) Accept

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

func (*StmtExportFuncDefineContext) AllCOMMA

func (s *StmtExportFuncDefineContext) AllCOMMA() []antlr.TerminalNode

func (*StmtExportFuncDefineContext) AllIDENTIFIER

func (s *StmtExportFuncDefineContext) AllIDENTIFIER() []antlr.TerminalNode

func (*StmtExportFuncDefineContext) COMMA

func (s *StmtExportFuncDefineContext) COMMA(i int) antlr.TerminalNode

func (*StmtExportFuncDefineContext) CodeBlock

func (s *StmtExportFuncDefineContext) CodeBlock() ICodeBlockContext

func (*StmtExportFuncDefineContext) EXPORT

func (s *StmtExportFuncDefineContext) EXPORT() antlr.TerminalNode

func (*StmtExportFuncDefineContext) FUNC

func (s *StmtExportFuncDefineContext) FUNC() antlr.TerminalNode

func (*StmtExportFuncDefineContext) GetRuleContext

func (s *StmtExportFuncDefineContext) GetRuleContext() antlr.RuleContext

func (*StmtExportFuncDefineContext) IDENTIFIER

func (s *StmtExportFuncDefineContext) IDENTIFIER(i int) antlr.TerminalNode

func (*StmtExportFuncDefineContext) L_PAREN

func (s *StmtExportFuncDefineContext) L_PAREN() antlr.TerminalNode

func (*StmtExportFuncDefineContext) MORE_ARGS

func (s *StmtExportFuncDefineContext) MORE_ARGS() antlr.TerminalNode

func (*StmtExportFuncDefineContext) R_PAREN

func (s *StmtExportFuncDefineContext) R_PAREN() antlr.TerminalNode

type StmtExportIdentifierContext

type StmtExportIdentifierContext struct {
	StmtContext
}

func NewStmtExportIdentifierContext

func NewStmtExportIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExportIdentifierContext

func (*StmtExportIdentifierContext) Accept

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

func (*StmtExportIdentifierContext) EXPORT

func (s *StmtExportIdentifierContext) EXPORT() antlr.TerminalNode

func (*StmtExportIdentifierContext) GetRuleContext

func (s *StmtExportIdentifierContext) GetRuleContext() antlr.RuleContext

func (*StmtExportIdentifierContext) IDENTIFIER

func (s *StmtExportIdentifierContext) IDENTIFIER() antlr.TerminalNode

type StmtExtendContext

type StmtExtendContext struct {
	StmtContext
}

func NewStmtExtendContext

func NewStmtExtendContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtExtendContext

func (*StmtExtendContext) Accept

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

func (*StmtExtendContext) AllKeyValue

func (s *StmtExtendContext) AllKeyValue() []IKeyValueContext

func (*StmtExtendContext) EXPORT

func (s *StmtExtendContext) EXPORT() antlr.TerminalNode

func (*StmtExtendContext) EXTEND

func (s *StmtExtendContext) EXTEND() antlr.TerminalNode

func (*StmtExtendContext) Expr

func (s *StmtExtendContext) Expr() IExprContext

func (*StmtExtendContext) GetRuleContext

func (s *StmtExtendContext) GetRuleContext() antlr.RuleContext

func (*StmtExtendContext) KeyValue

func (s *StmtExtendContext) KeyValue(i int) IKeyValueContext

func (*StmtExtendContext) L_CURLY

func (s *StmtExtendContext) L_CURLY() antlr.TerminalNode

func (*StmtExtendContext) R_CURLY

func (s *StmtExtendContext) R_CURLY() antlr.TerminalNode

type StmtForContext

type StmtForContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtForContext

func NewStmtForContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtForContext

func (*StmtForContext) Accept

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

func (*StmtForContext) AllExpr

func (s *StmtForContext) AllExpr() []IExprContext

func (*StmtForContext) AllSEMICOLON

func (s *StmtForContext) AllSEMICOLON() []antlr.TerminalNode

func (*StmtForContext) COLON

func (s *StmtForContext) COLON() antlr.TerminalNode

func (*StmtForContext) CodeBlock

func (s *StmtForContext) CodeBlock() ICodeBlockContext

func (*StmtForContext) Expr

func (s *StmtForContext) Expr(i int) IExprContext

func (*StmtForContext) FOR

func (s *StmtForContext) FOR() antlr.TerminalNode

func (*StmtForContext) GetCheckExpr

func (s *StmtForContext) GetCheckExpr() IExprContext

func (*StmtForContext) GetExecBlock

func (s *StmtForContext) GetExecBlock() ICodeBlockContext

func (*StmtForContext) GetInitExpr

func (s *StmtForContext) GetInitExpr() IExprContext

func (*StmtForContext) GetLabel

func (s *StmtForContext) GetLabel() antlr.Token

func (*StmtForContext) GetNextExpr

func (s *StmtForContext) GetNextExpr() IExprContext

func (*StmtForContext) GetRuleContext

func (s *StmtForContext) GetRuleContext() antlr.RuleContext

func (*StmtForContext) IDENTIFIER

func (s *StmtForContext) IDENTIFIER() antlr.TerminalNode

func (*StmtForContext) SEMICOLON

func (s *StmtForContext) SEMICOLON(i int) antlr.TerminalNode

func (*StmtForContext) SetCheckExpr

func (s *StmtForContext) SetCheckExpr(v IExprContext)

func (*StmtForContext) SetExecBlock

func (s *StmtForContext) SetExecBlock(v ICodeBlockContext)

func (*StmtForContext) SetInitExpr

func (s *StmtForContext) SetInitExpr(v IExprContext)

func (*StmtForContext) SetLabel

func (s *StmtForContext) SetLabel(v antlr.Token)

func (*StmtForContext) SetNextExpr

func (s *StmtForContext) SetNextExpr(v IExprContext)

type StmtForEachContext

type StmtForEachContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtForEachContext

func NewStmtForEachContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtForEachContext

func (*StmtForEachContext) Accept

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

func (*StmtForEachContext) AllExpr

func (s *StmtForEachContext) AllExpr() []IExprContext

func (*StmtForEachContext) AllIDENTIFIER

func (s *StmtForEachContext) AllIDENTIFIER() []antlr.TerminalNode

func (*StmtForEachContext) COLON

func (s *StmtForEachContext) COLON() antlr.TerminalNode

func (*StmtForEachContext) COMMA

func (s *StmtForEachContext) COMMA() antlr.TerminalNode

func (*StmtForEachContext) CodeBlock

func (s *StmtForEachContext) CodeBlock() ICodeBlockContext

func (*StmtForEachContext) Expr

func (s *StmtForEachContext) Expr(i int) IExprContext

func (*StmtForEachContext) FOR

func (s *StmtForEachContext) FOR() antlr.TerminalNode

func (*StmtForEachContext) GetBegin

func (s *StmtForEachContext) GetBegin() IExprContext

func (*StmtForEachContext) GetEnd

func (s *StmtForEachContext) GetEnd() IExprContext

func (*StmtForEachContext) GetExecBlock

func (s *StmtForEachContext) GetExecBlock() ICodeBlockContext

func (*StmtForEachContext) GetIdIndex

func (s *StmtForEachContext) GetIdIndex() antlr.Token

func (*StmtForEachContext) GetIdValue

func (s *StmtForEachContext) GetIdValue() antlr.Token

func (*StmtForEachContext) GetLabel

func (s *StmtForEachContext) GetLabel() antlr.Token

func (*StmtForEachContext) GetRuleContext

func (s *StmtForEachContext) GetRuleContext() antlr.RuleContext

func (*StmtForEachContext) IDENTIFIER

func (s *StmtForEachContext) IDENTIFIER(i int) antlr.TerminalNode

func (*StmtForEachContext) IN

func (s *StmtForEachContext) IN() antlr.TerminalNode

func (*StmtForEachContext) RANGE_WITHOUT_END

func (s *StmtForEachContext) RANGE_WITHOUT_END() antlr.TerminalNode

func (*StmtForEachContext) RANGE_WITH_END

func (s *StmtForEachContext) RANGE_WITH_END() antlr.TerminalNode

func (*StmtForEachContext) SetBegin

func (s *StmtForEachContext) SetBegin(v IExprContext)

func (*StmtForEachContext) SetEnd

func (s *StmtForEachContext) SetEnd(v IExprContext)

func (*StmtForEachContext) SetExecBlock

func (s *StmtForEachContext) SetExecBlock(v ICodeBlockContext)

func (*StmtForEachContext) SetIdIndex

func (s *StmtForEachContext) SetIdIndex(v antlr.Token)

func (*StmtForEachContext) SetIdValue

func (s *StmtForEachContext) SetIdValue(v antlr.Token)

func (*StmtForEachContext) SetLabel

func (s *StmtForEachContext) SetLabel(v antlr.Token)

type StmtFuncCallContext

type StmtFuncCallContext struct {
	StmtContext
}

func NewStmtFuncCallContext

func NewStmtFuncCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtFuncCallContext

func (*StmtFuncCallContext) Accept

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

func (*StmtFuncCallContext) CallStmt

func (s *StmtFuncCallContext) CallStmt() ICallStmtContext

func (*StmtFuncCallContext) GetRuleContext

func (s *StmtFuncCallContext) GetRuleContext() antlr.RuleContext

type StmtFuncDefineContext

type StmtFuncDefineContext struct {
	StmtContext
}

func NewStmtFuncDefineContext

func NewStmtFuncDefineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtFuncDefineContext

func (*StmtFuncDefineContext) Accept

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

func (*StmtFuncDefineContext) AllCOMMA

func (s *StmtFuncDefineContext) AllCOMMA() []antlr.TerminalNode

func (*StmtFuncDefineContext) AllIDENTIFIER

func (s *StmtFuncDefineContext) AllIDENTIFIER() []antlr.TerminalNode

func (*StmtFuncDefineContext) COMMA

func (s *StmtFuncDefineContext) COMMA(i int) antlr.TerminalNode

func (*StmtFuncDefineContext) CodeBlock

func (s *StmtFuncDefineContext) CodeBlock() ICodeBlockContext

func (*StmtFuncDefineContext) FUNC

func (s *StmtFuncDefineContext) FUNC() antlr.TerminalNode

func (*StmtFuncDefineContext) GetRuleContext

func (s *StmtFuncDefineContext) GetRuleContext() antlr.RuleContext

func (*StmtFuncDefineContext) IDENTIFIER

func (s *StmtFuncDefineContext) IDENTIFIER(i int) antlr.TerminalNode

func (*StmtFuncDefineContext) L_PAREN

func (s *StmtFuncDefineContext) L_PAREN() antlr.TerminalNode

func (*StmtFuncDefineContext) MORE_ARGS

func (s *StmtFuncDefineContext) MORE_ARGS() antlr.TerminalNode

func (*StmtFuncDefineContext) R_PAREN

func (s *StmtFuncDefineContext) R_PAREN() antlr.TerminalNode

type StmtIfContext

type StmtIfContext struct {
	StmtContext
}

func NewStmtIfContext

func NewStmtIfContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtIfContext

func (*StmtIfContext) Accept

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

func (*StmtIfContext) AllCodeBlock

func (s *StmtIfContext) AllCodeBlock() []ICodeBlockContext

func (*StmtIfContext) AllELSE

func (s *StmtIfContext) AllELSE() []antlr.TerminalNode

func (*StmtIfContext) AllIF

func (s *StmtIfContext) AllIF() []antlr.TerminalNode

func (*StmtIfContext) AllIfCondition

func (s *StmtIfContext) AllIfCondition() []IIfConditionContext

func (*StmtIfContext) CodeBlock

func (s *StmtIfContext) CodeBlock(i int) ICodeBlockContext

func (*StmtIfContext) ELSE

func (s *StmtIfContext) ELSE(i int) antlr.TerminalNode

func (*StmtIfContext) GetRuleContext

func (s *StmtIfContext) GetRuleContext() antlr.RuleContext

func (*StmtIfContext) IF

func (s *StmtIfContext) IF(i int) antlr.TerminalNode

func (*StmtIfContext) IfCondition

func (s *StmtIfContext) IfCondition(i int) IIfConditionContext

type StmtPostIncDecContext

type StmtPostIncDecContext struct {
	StmtContext
}

func NewStmtPostIncDecContext

func NewStmtPostIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtPostIncDecContext

func (*StmtPostIncDecContext) Accept

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

func (*StmtPostIncDecContext) GetRuleContext

func (s *StmtPostIncDecContext) GetRuleContext() antlr.RuleContext

func (*StmtPostIncDecContext) PostIncDec

func (s *StmtPostIncDecContext) PostIncDec() IPostIncDecContext

type StmtPreIncDecContext

type StmtPreIncDecContext struct {
	StmtContext
}

func NewStmtPreIncDecContext

func NewStmtPreIncDecContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtPreIncDecContext

func (*StmtPreIncDecContext) Accept

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

func (*StmtPreIncDecContext) GetRuleContext

func (s *StmtPreIncDecContext) GetRuleContext() antlr.RuleContext

func (*StmtPreIncDecContext) PreIncDec

func (s *StmtPreIncDecContext) PreIncDec() IPreIncDecContext

type StmtReturnContext

type StmtReturnContext struct {
	StmtContext
}

func NewStmtReturnContext

func NewStmtReturnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtReturnContext

func (*StmtReturnContext) Accept

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

func (*StmtReturnContext) Expr

func (s *StmtReturnContext) Expr() IExprContext

func (*StmtReturnContext) GetRuleContext

func (s *StmtReturnContext) GetRuleContext() antlr.RuleContext

func (*StmtReturnContext) RETURN

func (s *StmtReturnContext) RETURN() antlr.TerminalNode

type StmtReturnNoneContext

type StmtReturnNoneContext struct {
	StmtContext
}

func NewStmtReturnNoneContext

func NewStmtReturnNoneContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtReturnNoneContext

func (*StmtReturnNoneContext) Accept

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

func (*StmtReturnNoneContext) GetRuleContext

func (s *StmtReturnNoneContext) GetRuleContext() antlr.RuleContext

func (*StmtReturnNoneContext) RETURN_NONE

func (s *StmtReturnNoneContext) RETURN_NONE() antlr.TerminalNode

type StmtSwitchContext

type StmtSwitchContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtSwitchContext

func NewStmtSwitchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtSwitchContext

func (*StmtSwitchContext) Accept

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

func (*StmtSwitchContext) AllSwitchCase

func (s *StmtSwitchContext) AllSwitchCase() []ISwitchCaseContext

func (*StmtSwitchContext) Expr

func (s *StmtSwitchContext) Expr() IExprContext

func (*StmtSwitchContext) GetRuleContext

func (s *StmtSwitchContext) GetRuleContext() antlr.RuleContext

func (*StmtSwitchContext) GetTestValue

func (s *StmtSwitchContext) GetTestValue() IExprContext

func (*StmtSwitchContext) L_CURLY

func (s *StmtSwitchContext) L_CURLY() antlr.TerminalNode

func (*StmtSwitchContext) R_CURLY

func (s *StmtSwitchContext) R_CURLY() antlr.TerminalNode

func (*StmtSwitchContext) SWITCH

func (s *StmtSwitchContext) SWITCH() antlr.TerminalNode

func (*StmtSwitchContext) SetTestValue

func (s *StmtSwitchContext) SetTestValue(v IExprContext)

func (*StmtSwitchContext) SwitchCase

func (s *StmtSwitchContext) SwitchCase(i int) ISwitchCaseContext

func (*StmtSwitchContext) SwitchDefault

func (s *StmtSwitchContext) SwitchDefault() ISwitchDefaultContext

type StmtTryContext

type StmtTryContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtTryContext

func NewStmtTryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtTryContext

func (*StmtTryContext) Accept

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

func (*StmtTryContext) AllCodeBlock

func (s *StmtTryContext) AllCodeBlock() []ICodeBlockContext

func (*StmtTryContext) CATCH

func (s *StmtTryContext) CATCH() antlr.TerminalNode

func (*StmtTryContext) CodeBlock

func (s *StmtTryContext) CodeBlock(i int) ICodeBlockContext

func (*StmtTryContext) FINALLY

func (s *StmtTryContext) FINALLY() antlr.TerminalNode

func (*StmtTryContext) GetCatchBlock

func (s *StmtTryContext) GetCatchBlock() ICodeBlockContext

func (*StmtTryContext) GetExcName

func (s *StmtTryContext) GetExcName() antlr.Token

func (*StmtTryContext) GetFinallyBlock

func (s *StmtTryContext) GetFinallyBlock() ICodeBlockContext

func (*StmtTryContext) GetRuleContext

func (s *StmtTryContext) GetRuleContext() antlr.RuleContext

func (*StmtTryContext) GetTryBlock

func (s *StmtTryContext) GetTryBlock() ICodeBlockContext

func (*StmtTryContext) IDENTIFIER

func (s *StmtTryContext) IDENTIFIER() antlr.TerminalNode

func (*StmtTryContext) L_PAREN

func (s *StmtTryContext) L_PAREN() antlr.TerminalNode

func (*StmtTryContext) R_PAREN

func (s *StmtTryContext) R_PAREN() antlr.TerminalNode

func (*StmtTryContext) SetCatchBlock

func (s *StmtTryContext) SetCatchBlock(v ICodeBlockContext)

func (*StmtTryContext) SetExcName

func (s *StmtTryContext) SetExcName(v antlr.Token)

func (*StmtTryContext) SetFinallyBlock

func (s *StmtTryContext) SetFinallyBlock(v ICodeBlockContext)

func (*StmtTryContext) SetTryBlock

func (s *StmtTryContext) SetTryBlock(v ICodeBlockContext)

func (*StmtTryContext) TRY

func (s *StmtTryContext) TRY() antlr.TerminalNode

type StmtWhileContext

type StmtWhileContext struct {
	StmtContext
	// contains filtered or unexported fields
}

func NewStmtWhileContext

func NewStmtWhileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StmtWhileContext

func (*StmtWhileContext) Accept

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

func (*StmtWhileContext) COLON

func (s *StmtWhileContext) COLON() antlr.TerminalNode

func (*StmtWhileContext) CodeBlock

func (s *StmtWhileContext) CodeBlock() ICodeBlockContext

func (*StmtWhileContext) Expr

func (s *StmtWhileContext) Expr() IExprContext

func (*StmtWhileContext) GetCheckExpr

func (s *StmtWhileContext) GetCheckExpr() IExprContext

func (*StmtWhileContext) GetExecBlock

func (s *StmtWhileContext) GetExecBlock() ICodeBlockContext

func (*StmtWhileContext) GetLabel

func (s *StmtWhileContext) GetLabel() antlr.Token

func (*StmtWhileContext) GetRuleContext

func (s *StmtWhileContext) GetRuleContext() antlr.RuleContext

func (*StmtWhileContext) IDENTIFIER

func (s *StmtWhileContext) IDENTIFIER() antlr.TerminalNode

func (*StmtWhileContext) SetCheckExpr

func (s *StmtWhileContext) SetCheckExpr(v IExprContext)

func (*StmtWhileContext) SetExecBlock

func (s *StmtWhileContext) SetExecBlock(v ICodeBlockContext)

func (*StmtWhileContext) SetLabel

func (s *StmtWhileContext) SetLabel(v antlr.Token)

func (*StmtWhileContext) WHILE

func (s *StmtWhileContext) WHILE() antlr.TerminalNode

type StringLiteralContext

type StringLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStringLiteralContext

func NewEmptyStringLiteralContext() *StringLiteralContext

func NewStringLiteralContext

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

func (*StringLiteralContext) Accept

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

func (*StringLiteralContext) GetParser

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

func (*StringLiteralContext) GetRuleContext

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

func (*StringLiteralContext) IsStringLiteralContext

func (*StringLiteralContext) IsStringLiteralContext()

func (*StringLiteralContext) RSTRING

func (s *StringLiteralContext) RSTRING() antlr.TerminalNode

func (*StringLiteralContext) STRING

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

func (*StringLiteralContext) TemplateString

func (s *StringLiteralContext) TemplateString() ITemplateStringContext

func (*StringLiteralContext) ToStringTree

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

type SwitchCaseContext

type SwitchCaseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySwitchCaseContext

func NewEmptySwitchCaseContext() *SwitchCaseContext

func NewSwitchCaseContext

func NewSwitchCaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchCaseContext

func (*SwitchCaseContext) Accept

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

func (*SwitchCaseContext) Block

func (s *SwitchCaseContext) Block() IBlockContext

func (*SwitchCaseContext) CASE

func (s *SwitchCaseContext) CASE() antlr.TerminalNode

func (*SwitchCaseContext) COLON

func (s *SwitchCaseContext) COLON() antlr.TerminalNode

func (*SwitchCaseContext) FALLTHROUGH

func (s *SwitchCaseContext) FALLTHROUGH() antlr.TerminalNode

func (*SwitchCaseContext) GetParser

func (s *SwitchCaseContext) GetParser() antlr.Parser

func (*SwitchCaseContext) GetRuleContext

func (s *SwitchCaseContext) GetRuleContext() antlr.RuleContext

func (*SwitchCaseContext) IsSwitchCaseContext

func (*SwitchCaseContext) IsSwitchCaseContext()

func (*SwitchCaseContext) ToStringTree

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

func (*SwitchCaseContext) WhenCondition

func (s *SwitchCaseContext) WhenCondition() IWhenConditionContext

type SwitchDefaultContext

type SwitchDefaultContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySwitchDefaultContext

func NewEmptySwitchDefaultContext() *SwitchDefaultContext

func NewSwitchDefaultContext

func NewSwitchDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchDefaultContext

func (*SwitchDefaultContext) Accept

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

func (*SwitchDefaultContext) Block

func (s *SwitchDefaultContext) Block() IBlockContext

func (*SwitchDefaultContext) COLON

func (s *SwitchDefaultContext) COLON() antlr.TerminalNode

func (*SwitchDefaultContext) DEFAULT

func (s *SwitchDefaultContext) DEFAULT() antlr.TerminalNode

func (*SwitchDefaultContext) GetParser

func (s *SwitchDefaultContext) GetParser() antlr.Parser

func (*SwitchDefaultContext) GetRuleContext

func (s *SwitchDefaultContext) GetRuleContext() antlr.RuleContext

func (*SwitchDefaultContext) IsSwitchDefaultContext

func (*SwitchDefaultContext) IsSwitchDefaultContext()

func (*SwitchDefaultContext) ToStringTree

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

type SyntaxErrorInfo

type SyntaxErrorInfo struct {
	FileName string
	Line     int
	Column   int
	Msg      string
}

func ParseFromString

func ParseFromString(filename, in string, shouldRecover bool) (ast.Node, []SyntaxErrorInfo)

func ParseReplFromString

func ParseReplFromString(in string, shouldRecover bool) (ast.Node, []SyntaxErrorInfo)

func (*SyntaxErrorInfo) Error

func (e *SyntaxErrorInfo) Error() string

func (*SyntaxErrorInfo) String

func (e *SyntaxErrorInfo) String() string

type TemplateStringContext

type TemplateStringContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTemplateStringContext

func NewEmptyTemplateStringContext() *TemplateStringContext

func NewTemplateStringContext

func NewTemplateStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringContext

func (*TemplateStringContext) Accept

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

func (*TemplateStringContext) AllQUOTE

func (s *TemplateStringContext) AllQUOTE() []antlr.TerminalNode

func (*TemplateStringContext) AllTsItem

func (s *TemplateStringContext) AllTsItem() []ITsItemContext

func (*TemplateStringContext) GetParser

func (s *TemplateStringContext) GetParser() antlr.Parser

func (*TemplateStringContext) GetRuleContext

func (s *TemplateStringContext) GetRuleContext() antlr.RuleContext

func (*TemplateStringContext) IsTemplateStringContext

func (*TemplateStringContext) IsTemplateStringContext()

func (*TemplateStringContext) QUOTE

func (s *TemplateStringContext) QUOTE(i int) antlr.TerminalNode

func (*TemplateStringContext) ToStringTree

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

func (*TemplateStringContext) TsItem

func (s *TemplateStringContext) TsItem(i int) ITsItemContext

type TsExprContext

type TsExprContext struct {
	TsItemContext
}

func NewTsExprContext

func NewTsExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsExprContext

func (*TsExprContext) Accept

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

func (*TsExprContext) Expr

func (s *TsExprContext) Expr() IExprContext

func (*TsExprContext) GetRuleContext

func (s *TsExprContext) GetRuleContext() antlr.RuleContext

func (*TsExprContext) R_CURLY

func (s *TsExprContext) R_CURLY() antlr.TerminalNode

func (*TsExprContext) TS_EXPR_START

func (s *TsExprContext) TS_EXPR_START() antlr.TerminalNode

type TsIdentifierContext

type TsIdentifierContext struct {
	TsItemContext
}

func NewTsIdentifierContext

func NewTsIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsIdentifierContext

func (*TsIdentifierContext) Accept

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

func (*TsIdentifierContext) GetRuleContext

func (s *TsIdentifierContext) GetRuleContext() antlr.RuleContext

func (*TsIdentifierContext) TS_IDENTIFIER

func (s *TsIdentifierContext) TS_IDENTIFIER() antlr.TerminalNode

type TsItemContext

type TsItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTsItemContext

func NewEmptyTsItemContext() *TsItemContext

func NewTsItemContext

func NewTsItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TsItemContext

func (*TsItemContext) CopyAll

func (s *TsItemContext) CopyAll(ctx *TsItemContext)

func (*TsItemContext) GetParser

func (s *TsItemContext) GetParser() antlr.Parser

func (*TsItemContext) GetRuleContext

func (s *TsItemContext) GetRuleContext() antlr.RuleContext

func (*TsItemContext) IsTsItemContext

func (*TsItemContext) IsTsItemContext()

func (*TsItemContext) ToStringTree

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

type TsRawContext

type TsRawContext struct {
	TsItemContext
}

func NewTsRawContext

func NewTsRawContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TsRawContext

func (*TsRawContext) Accept

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

func (*TsRawContext) GetRuleContext

func (s *TsRawContext) GetRuleContext() antlr.RuleContext

func (*TsRawContext) TS_RAW

func (s *TsRawContext) TS_RAW() antlr.TerminalNode

type WhenConditionContext

type WhenConditionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWhenConditionContext

func NewEmptyWhenConditionContext() *WhenConditionContext

func NewWhenConditionContext

func NewWhenConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenConditionContext

func (*WhenConditionContext) CopyAll

func (s *WhenConditionContext) CopyAll(ctx *WhenConditionContext)

func (*WhenConditionContext) GetParser

func (s *WhenConditionContext) GetParser() antlr.Parser

func (*WhenConditionContext) GetRuleContext

func (s *WhenConditionContext) GetRuleContext() antlr.RuleContext

func (*WhenConditionContext) IsWhenConditionContext

func (*WhenConditionContext) IsWhenConditionContext()

func (*WhenConditionContext) ToStringTree

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

type WhenConditionInListContext

type WhenConditionInListContext struct {
	WhenConditionContext
}

func NewWhenConditionInListContext

func NewWhenConditionInListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionInListContext

func (*WhenConditionInListContext) Accept

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

func (*WhenConditionInListContext) AllCOMMA

func (s *WhenConditionInListContext) AllCOMMA() []antlr.TerminalNode

func (*WhenConditionInListContext) AllExpr

func (s *WhenConditionInListContext) AllExpr() []IExprContext

func (*WhenConditionInListContext) COMMA

func (s *WhenConditionInListContext) COMMA(i int) antlr.TerminalNode

func (*WhenConditionInListContext) Expr

func (s *WhenConditionInListContext) Expr(i int) IExprContext

func (*WhenConditionInListContext) GetRuleContext

func (s *WhenConditionInListContext) GetRuleContext() antlr.RuleContext

type WhenConditionInRangeContext

type WhenConditionInRangeContext struct {
	WhenConditionContext
	// contains filtered or unexported fields
}

func NewWhenConditionInRangeContext

func NewWhenConditionInRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionInRangeContext

func (*WhenConditionInRangeContext) Accept

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

func (*WhenConditionInRangeContext) AllExpr

func (s *WhenConditionInRangeContext) AllExpr() []IExprContext

func (*WhenConditionInRangeContext) Expr

func (s *WhenConditionInRangeContext) Expr(i int) IExprContext

func (*WhenConditionInRangeContext) GetLowerBound

func (s *WhenConditionInRangeContext) GetLowerBound() IExprContext

func (*WhenConditionInRangeContext) GetRuleContext

func (s *WhenConditionInRangeContext) GetRuleContext() antlr.RuleContext

func (*WhenConditionInRangeContext) GetUpperBound

func (s *WhenConditionInRangeContext) GetUpperBound() IExprContext

func (*WhenConditionInRangeContext) RANGE_WITHOUT_END

func (s *WhenConditionInRangeContext) RANGE_WITHOUT_END() antlr.TerminalNode

func (*WhenConditionInRangeContext) RANGE_WITH_END

func (s *WhenConditionInRangeContext) RANGE_WITH_END() antlr.TerminalNode

func (*WhenConditionInRangeContext) SetLowerBound

func (s *WhenConditionInRangeContext) SetLowerBound(v IExprContext)

func (*WhenConditionInRangeContext) SetUpperBound

func (s *WhenConditionInRangeContext) SetUpperBound(v IExprContext)

type WhenConditionIsTypeContext

type WhenConditionIsTypeContext struct {
	WhenConditionContext
}

func NewWhenConditionIsTypeContext

func NewWhenConditionIsTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionIsTypeContext

func (*WhenConditionIsTypeContext) Accept

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

func (*WhenConditionIsTypeContext) Expr

func (s *WhenConditionIsTypeContext) Expr() IExprContext

func (*WhenConditionIsTypeContext) GetRuleContext

func (s *WhenConditionIsTypeContext) GetRuleContext() antlr.RuleContext

func (*WhenConditionIsTypeContext) IS

func (s *WhenConditionIsTypeContext) IS() antlr.TerminalNode

type ZggBaseParser

type ZggBaseParser struct {
	*antlr.BaseParser
}

type ZggLexer

type ZggLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewZggLexer

func NewZggLexer(input antlr.CharStream) *ZggLexer

NewZggLexer produces a new lexer instance for the optional input antlr.CharStream.

type ZggParser

type ZggParser struct {
	ZggBaseParser
}

func NewZggParser

func NewZggParser(input antlr.TokenStream) *ZggParser

NewZggParser produces a new parser instance for the optional input antlr.TokenStream.

func (*ZggParser) Arguments

func (p *ZggParser) Arguments() (localctx IArgumentsContext)

func (*ZggParser) ArrayItem

func (p *ZggParser) ArrayItem() (localctx IArrayItemContext)

func (*ZggParser) AssignExpr

func (p *ZggParser) AssignExpr() (localctx IAssignExprContext)

func (*ZggParser) Block

func (p *ZggParser) Block() (localctx IBlockContext)

func (*ZggParser) CallStmt

func (p *ZggParser) CallStmt() (localctx ICallStmtContext)

func (*ZggParser) CodeBlock

func (p *ZggParser) CodeBlock() (localctx ICodeBlockContext)

func (*ZggParser) Comparator

func (p *ZggParser) Comparator() (localctx IComparatorContext)

func (*ZggParser) Expr

func (p *ZggParser) Expr() (localctx IExprContext)

func (*ZggParser) Expr_Sempred

func (p *ZggParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ZggParser) FuncArgument

func (p *ZggParser) FuncArgument() (localctx IFuncArgumentContext)

func (*ZggParser) IfCondition

func (p *ZggParser) IfCondition() (localctx IIfConditionContext)

func (*ZggParser) Integer

func (p *ZggParser) Integer() (localctx IIntegerContext)

func (*ZggParser) KeyValue

func (p *ZggParser) KeyValue() (localctx IKeyValueContext)

func (*ZggParser) Literal

func (p *ZggParser) Literal() (localctx ILiteralContext)

func (*ZggParser) Lval

func (p *ZggParser) Lval() (localctx ILvalContext)

func (*ZggParser) Lval_Sempred

func (p *ZggParser) Lval_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ZggParser) MemberDef

func (p *ZggParser) MemberDef() (localctx IMemberDefContext)

func (*ZggParser) Module

func (p *ZggParser) Module() (localctx IModuleContext)

func (*ZggParser) ObjItem

func (p *ZggParser) ObjItem() (localctx IObjItemContext)

func (*ZggParser) PostIncDec

func (p *ZggParser) PostIncDec() (localctx IPostIncDecContext)

func (*ZggParser) PreIncDec

func (p *ZggParser) PreIncDec() (localctx IPreIncDecContext)

func (*ZggParser) ReplItem

func (p *ZggParser) ReplItem() (localctx IReplItemContext)

func (*ZggParser) Sempred

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

func (*ZggParser) Stmt

func (p *ZggParser) Stmt() (localctx IStmtContext)

func (*ZggParser) StringLiteral

func (p *ZggParser) StringLiteral() (localctx IStringLiteralContext)

func (*ZggParser) SwitchCase

func (p *ZggParser) SwitchCase() (localctx ISwitchCaseContext)

func (*ZggParser) SwitchDefault

func (p *ZggParser) SwitchDefault() (localctx ISwitchDefaultContext)

func (*ZggParser) TemplateString

func (p *ZggParser) TemplateString() (localctx ITemplateStringContext)

func (*ZggParser) TsItem

func (p *ZggParser) TsItem() (localctx ITsItemContext)

func (*ZggParser) WhenCondition

func (p *ZggParser) WhenCondition() (localctx IWhenConditionContext)

type ZggParserVisitor

type ZggParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by ZggParser#replExpr.
	VisitReplExpr(ctx *ReplExprContext) interface{}

	// Visit a parse tree produced by ZggParser#replBlock.
	VisitReplBlock(ctx *ReplBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#module.
	VisitModule(ctx *ModuleContext) interface{}

	// Visit a parse tree produced by ZggParser#block.
	VisitBlock(ctx *BlockContext) interface{}

	// Visit a parse tree produced by ZggParser#codeBlock.
	VisitCodeBlock(ctx *CodeBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtBlock.
	VisitStmtBlock(ctx *StmtBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#StmtPreIncDec.
	VisitStmtPreIncDec(ctx *StmtPreIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#StmtPostIncDec.
	VisitStmtPostIncDec(ctx *StmtPostIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtAssign.
	VisitStmtAssign(ctx *StmtAssignContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtFuncCall.
	VisitStmtFuncCall(ctx *StmtFuncCallContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtFuncDefine.
	VisitStmtFuncDefine(ctx *StmtFuncDefineContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtClassDefine.
	VisitStmtClassDefine(ctx *StmtClassDefineContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtFor.
	VisitStmtFor(ctx *StmtForContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtForEach.
	VisitStmtForEach(ctx *StmtForEachContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtDoWhile.
	VisitStmtDoWhile(ctx *StmtDoWhileContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtWhile.
	VisitStmtWhile(ctx *StmtWhileContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtContinue.
	VisitStmtContinue(ctx *StmtContinueContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtBreak.
	VisitStmtBreak(ctx *StmtBreakContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtIf.
	VisitStmtIf(ctx *StmtIfContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtSwitch.
	VisitStmtSwitch(ctx *StmtSwitchContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtReturnNone.
	VisitStmtReturnNone(ctx *StmtReturnNoneContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtReturn.
	VisitStmtReturn(ctx *StmtReturnContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtExportIdentifier.
	VisitStmtExportIdentifier(ctx *StmtExportIdentifierContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtExportExpr.
	VisitStmtExportExpr(ctx *StmtExportExprContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtExportFuncDefine.
	VisitStmtExportFuncDefine(ctx *StmtExportFuncDefineContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtDefer.
	VisitStmtDefer(ctx *StmtDeferContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtDeferBlock.
	VisitStmtDeferBlock(ctx *StmtDeferBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtTry.
	VisitStmtTry(ctx *StmtTryContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtAssert.
	VisitStmtAssert(ctx *StmtAssertContext) interface{}

	// Visit a parse tree produced by ZggParser#stmtExtend.
	VisitStmtExtend(ctx *StmtExtendContext) interface{}

	// Visit a parse tree produced by ZggParser#ifCondition.
	VisitIfCondition(ctx *IfConditionContext) interface{}

	// Visit a parse tree produced by ZggParser#memberDef.
	VisitMemberDef(ctx *MemberDefContext) interface{}

	// Visit a parse tree produced by ZggParser#callStmt.
	VisitCallStmt(ctx *CallStmtContext) interface{}

	// Visit a parse tree produced by ZggParser#switchCase.
	VisitSwitchCase(ctx *SwitchCaseContext) interface{}

	// Visit a parse tree produced by ZggParser#switchDefault.
	VisitSwitchDefault(ctx *SwitchDefaultContext) interface{}

	// Visit a parse tree produced by ZggParser#comparator.
	VisitComparator(ctx *ComparatorContext) interface{}

	// Visit a parse tree produced by ZggParser#exprPlusMinus.
	VisitExprPlusMinus(ctx *ExprPlusMinusContext) interface{}

	// Visit a parse tree produced by ZggParser#exprUseCloser.
	VisitExprUseCloser(ctx *ExprUseCloserContext) interface{}

	// Visit a parse tree produced by ZggParser#exprInRange.
	VisitExprInRange(ctx *ExprInRangeContext) interface{}

	// Visit a parse tree produced by ZggParser#exprAssign.
	VisitExprAssign(ctx *ExprAssignContext) interface{}

	// Visit a parse tree produced by ZggParser#exprInContainer.
	VisitExprInContainer(ctx *ExprInContainerContext) interface{}

	// Visit a parse tree produced by ZggParser#exprUseMethod.
	VisitExprUseMethod(ctx *ExprUseMethodContext) interface{}

	// Visit a parse tree produced by ZggParser#exprWhenValue.
	VisitExprWhenValue(ctx *ExprWhenValueContext) interface{}

	// Visit a parse tree produced by ZggParser#exprLiteral.
	VisitExprLiteral(ctx *ExprLiteralContext) interface{}

	// Visit a parse tree produced by ZggParser#exprCompare.
	VisitExprCompare(ctx *ExprCompareContext) interface{}

	// Visit a parse tree produced by ZggParser#exprByField.
	VisitExprByField(ctx *ExprByFieldContext) interface{}

	// Visit a parse tree produced by ZggParser#exprLogicOr.
	VisitExprLogicOr(ctx *ExprLogicOrContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBitXor.
	VisitExprBitXor(ctx *ExprBitXorContext) interface{}

	// Visit a parse tree produced by ZggParser#exprPreIncDec.
	VisitExprPreIncDec(ctx *ExprPreIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#exprUseBlock.
	VisitExprUseBlock(ctx *ExprUseBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#exprPow.
	VisitExprPow(ctx *ExprPowContext) interface{}

	// Visit a parse tree produced by ZggParser#exprWhen.
	VisitExprWhen(ctx *ExprWhenContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBitShift.
	VisitExprBitShift(ctx *ExprBitShiftContext) interface{}

	// Visit a parse tree produced by ZggParser#exprLogicNot.
	VisitExprLogicNot(ctx *ExprLogicNotContext) interface{}

	// Visit a parse tree produced by ZggParser#exprItByField.
	VisitExprItByField(ctx *ExprItByFieldContext) interface{}

	// Visit a parse tree produced by ZggParser#exprLogicAnd.
	VisitExprLogicAnd(ctx *ExprLogicAndContext) interface{}

	// Visit a parse tree produced by ZggParser#exprIdentifier.
	VisitExprIdentifier(ctx *ExprIdentifierContext) interface{}

	// Visit a parse tree produced by ZggParser#exprFallback.
	VisitExprFallback(ctx *ExprFallbackContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBitAnd.
	VisitExprBitAnd(ctx *ExprBitAndContext) interface{}

	// Visit a parse tree produced by ZggParser#exprNegative.
	VisitExprNegative(ctx *ExprNegativeContext) interface{}

	// Visit a parse tree produced by ZggParser#exprTimesDivMod.
	VisitExprTimesDivMod(ctx *ExprTimesDivModContext) interface{}

	// Visit a parse tree produced by ZggParser#exprByIndex.
	VisitExprByIndex(ctx *ExprByIndexContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBitNot.
	VisitExprBitNot(ctx *ExprBitNotContext) interface{}

	// Visit a parse tree produced by ZggParser#exprShortImport.
	VisitExprShortImport(ctx *ExprShortImportContext) interface{}

	// Visit a parse tree produced by ZggParser#exprSub.
	VisitExprSub(ctx *ExprSubContext) interface{}

	// Visit a parse tree produced by ZggParser#exprCall.
	VisitExprCall(ctx *ExprCallContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBitOr.
	VisitExprBitOr(ctx *ExprBitOrContext) interface{}

	// Visit a parse tree produced by ZggParser#exprAssertError.
	VisitExprAssertError(ctx *ExprAssertErrorContext) interface{}

	// Visit a parse tree produced by ZggParser#exprQuestion.
	VisitExprQuestion(ctx *ExprQuestionContext) interface{}

	// Visit a parse tree produced by ZggParser#exprPostIncDec.
	VisitExprPostIncDec(ctx *ExprPostIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#exprBySlice.
	VisitExprBySlice(ctx *ExprBySliceContext) interface{}

	// Visit a parse tree produced by ZggParser#exprIsType.
	VisitExprIsType(ctx *ExprIsTypeContext) interface{}

	// Visit a parse tree produced by ZggParser#whenConditionInList.
	VisitWhenConditionInList(ctx *WhenConditionInListContext) interface{}

	// Visit a parse tree produced by ZggParser#whenConditionInRange.
	VisitWhenConditionInRange(ctx *WhenConditionInRangeContext) interface{}

	// Visit a parse tree produced by ZggParser#whenConditionIsType.
	VisitWhenConditionIsType(ctx *WhenConditionIsTypeContext) interface{}

	// Visit a parse tree produced by ZggParser#arguments.
	VisitArguments(ctx *ArgumentsContext) interface{}

	// Visit a parse tree produced by ZggParser#funcArgument.
	VisitFuncArgument(ctx *FuncArgumentContext) interface{}

	// Visit a parse tree produced by ZggParser#assignExists.
	VisitAssignExists(ctx *AssignExistsContext) interface{}

	// Visit a parse tree produced by ZggParser#assignNew.
	VisitAssignNew(ctx *AssignNewContext) interface{}

	// Visit a parse tree produced by ZggParser#assignNewDeArray.
	VisitAssignNewDeArray(ctx *AssignNewDeArrayContext) interface{}

	// Visit a parse tree produced by ZggParser#assignNewDeObject.
	VisitAssignNewDeObject(ctx *AssignNewDeObjectContext) interface{}

	// Visit a parse tree produced by ZggParser#assignNewLocal.
	VisitAssignNewLocal(ctx *AssignNewLocalContext) interface{}

	// Visit a parse tree produced by ZggParser#preIncDec.
	VisitPreIncDec(ctx *PreIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#postIncDec.
	VisitPostIncDec(ctx *PostIncDecContext) interface{}

	// Visit a parse tree produced by ZggParser#lvalById.
	VisitLvalById(ctx *LvalByIdContext) interface{}

	// Visit a parse tree produced by ZggParser#lvalByIndex.
	VisitLvalByIndex(ctx *LvalByIndexContext) interface{}

	// Visit a parse tree produced by ZggParser#lvalItByField.
	VisitLvalItByField(ctx *LvalItByFieldContext) interface{}

	// Visit a parse tree produced by ZggParser#lvalByField.
	VisitLvalByField(ctx *LvalByFieldContext) interface{}

	// Visit a parse tree produced by ZggParser#IntegerZero.
	VisitIntegerZero(ctx *IntegerZeroContext) interface{}

	// Visit a parse tree produced by ZggParser#IntegerDec.
	VisitIntegerDec(ctx *IntegerDecContext) interface{}

	// Visit a parse tree produced by ZggParser#IntegerHex.
	VisitIntegerHex(ctx *IntegerHexContext) interface{}

	// Visit a parse tree produced by ZggParser#IntegerOct.
	VisitIntegerOct(ctx *IntegerOctContext) interface{}

	// Visit a parse tree produced by ZggParser#IntegerBin.
	VisitIntegerBin(ctx *IntegerBinContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralInteger.
	VisitLiteralInteger(ctx *LiteralIntegerContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralFloat.
	VisitLiteralFloat(ctx *LiteralFloatContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralENum.
	VisitLiteralENum(ctx *LiteralENumContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralBigNum.
	VisitLiteralBigNum(ctx *LiteralBigNumContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralBool.
	VisitLiteralBool(ctx *LiteralBoolContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralString.
	VisitLiteralString(ctx *LiteralStringContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralNil.
	VisitLiteralNil(ctx *LiteralNilContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralUndefined.
	VisitLiteralUndefined(ctx *LiteralUndefinedContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralFunc.
	VisitLiteralFunc(ctx *LiteralFuncContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralLambdaExpr.
	VisitLiteralLambdaExpr(ctx *LiteralLambdaExprContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralLambdaBlock.
	VisitLiteralLambdaBlock(ctx *LiteralLambdaBlockContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralObject.
	VisitLiteralObject(ctx *LiteralObjectContext) interface{}

	// Visit a parse tree produced by ZggParser#ObjectComprehension.
	VisitObjectComprehension(ctx *ObjectComprehensionContext) interface{}

	// Visit a parse tree produced by ZggParser#LiteralArray.
	VisitLiteralArray(ctx *LiteralArrayContext) interface{}

	// Visit a parse tree produced by ZggParser#ArrayComprehension.
	VisitArrayComprehension(ctx *ArrayComprehensionContext) interface{}

	// Visit a parse tree produced by ZggParser#arrayItem.
	VisitArrayItem(ctx *ArrayItemContext) interface{}

	// Visit a parse tree produced by ZggParser#ObjItemKV.
	VisitObjItemKV(ctx *ObjItemKVContext) interface{}

	// Visit a parse tree produced by ZggParser#ObjItemExpanded.
	VisitObjItemExpanded(ctx *ObjItemExpandedContext) interface{}

	// Visit a parse tree produced by ZggParser#KVIdKey.
	VisitKVIdKey(ctx *KVIdKeyContext) interface{}

	// Visit a parse tree produced by ZggParser#KVStrKey.
	VisitKVStrKey(ctx *KVStrKeyContext) interface{}

	// Visit a parse tree produced by ZggParser#KVExprKey.
	VisitKVExprKey(ctx *KVExprKeyContext) interface{}

	// Visit a parse tree produced by ZggParser#KVKeyFunc.
	VisitKVKeyFunc(ctx *KVKeyFuncContext) interface{}

	// Visit a parse tree produced by ZggParser#KVIdOnly.
	VisitKVIdOnly(ctx *KVIdOnlyContext) interface{}

	// Visit a parse tree produced by ZggParser#KVExprOnly.
	VisitKVExprOnly(ctx *KVExprOnlyContext) interface{}

	// Visit a parse tree produced by ZggParser#stringLiteral.
	VisitStringLiteral(ctx *StringLiteralContext) interface{}

	// Visit a parse tree produced by ZggParser#templateString.
	VisitTemplateString(ctx *TemplateStringContext) interface{}

	// Visit a parse tree produced by ZggParser#tsRaw.
	VisitTsRaw(ctx *TsRawContext) interface{}

	// Visit a parse tree produced by ZggParser#tsIdentifier.
	VisitTsIdentifier(ctx *TsIdentifierContext) interface{}

	// Visit a parse tree produced by ZggParser#tsExpr.
	VisitTsExpr(ctx *TsExprContext) interface{}
}

A complete Visitor for a parse tree produced by ZggParser.