parser

package
v1.0.18 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 26, 2023 License: MIT Imports: 20 Imported by: 0

Documentation

Index

Constants

View Source 
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
	ZggLexerSTRING            = 46
	ZggLexerRSTRING           = 47
	ZggLexerMORE_ARGS         = 48
	ZggLexerLEAD_TO           = 49
	ZggLexerARROW             = 50
	ZggLexerPOW               = 51
	ZggLexerPLUS_PLUS         = 52
	ZggLexerMINUS_MINUS       = 53
	ZggLexerEQUAL             = 54
	ZggLexerNOT_EQUAL         = 55
	ZggLexerGTEQ              = 56
	ZggLexerLTEQ              = 57
	ZggLexerLOCAL_ASSIGN      = 58
	ZggLexerPLUS_ASSIGN       = 59
	ZggLexerMINUS_ASSIGN      = 60
	ZggLexerTIMES_ASSIGN      = 61
	ZggLexerDIV_ASSIGN        = 62
	ZggLexerMOD_ASSIGN        = 63
	ZggLexerLOGIC_AND         = 64
	ZggLexerLOGIC_OR          = 65
	ZggLexerOPTIONAL_CALL     = 66
	ZggLexerOPTIONAL_ELSE     = 67
	ZggLexerBIT_AND           = 68
	ZggLexerBIT_OR            = 69
	ZggLexerBIT_NOT           = 70
	ZggLexerBIT_SHL           = 71
	ZggLexerBIT_SHR           = 72
	ZggLexerBIT_XOR           = 73
	ZggLexerBIT_AND_ASSIGN    = 74
	ZggLexerBIT_OR_ASSIGN     = 75
	ZggLexerBIT_SHL_ASSIGN    = 76
	ZggLexerBIT_SHR_ASSIGN    = 77
	ZggLexerBIT_XOR_ASSIGN    = 78
	ZggLexerRANGE_WITHOUT_END = 79
	ZggLexerRANGE_WITH_END    = 80
	ZggLexerDOT               = 81
	ZggLexerCOMMA             = 82
	ZggLexerSEMICOLON         = 83
	ZggLexerCOLON             = 84
	ZggLexerL_PAREN           = 85
	ZggLexerR_PAREN           = 86
	ZggLexerL_CURLY           = 87
	ZggLexerR_CURLY           = 88
	ZggLexerL_BRACKET         = 89
	ZggLexerR_BRACKET         = 90
	ZggLexerLOGIC_NOT         = 91
	ZggLexerQUESTION          = 92
	ZggLexerGT                = 93
	ZggLexerLT                = 94
	ZggLexerASSIGN            = 95
	ZggLexerPLUS              = 96
	ZggLexerMINUS             = 97
	ZggLexerTIMES             = 98
	ZggLexerDIV               = 99
	ZggLexerMOD               = 100
	ZggLexerSINGLE_AT         = 101
	ZggLexerDOUBLE_AT         = 102
	ZggLexerQUOTE             = 103
	ZggLexerIDENTIFIER        = 104
	ZggLexerTS_RAW            = 105
	ZggLexerTS_EXPR_START     = 106
	ZggLexerTS_IDENTIFIER     = 107
	ZggLexerStrExpr_WS        = 108
)

ZggLexer tokens.

View Source 
const (
	ZggLexerTemplateString = iota + 1
	ZggLexerStrExpr
)

ZggLexer modes.

View Source 
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
	ZggParserSTRING            = 46
	ZggParserRSTRING           = 47
	ZggParserMORE_ARGS         = 48
	ZggParserLEAD_TO           = 49
	ZggParserARROW             = 50
	ZggParserPOW               = 51
	ZggParserPLUS_PLUS         = 52
	ZggParserMINUS_MINUS       = 53
	ZggParserEQUAL             = 54
	ZggParserNOT_EQUAL         = 55
	ZggParserGTEQ              = 56
	ZggParserLTEQ              = 57
	ZggParserLOCAL_ASSIGN      = 58
	ZggParserPLUS_ASSIGN       = 59
	ZggParserMINUS_ASSIGN      = 60
	ZggParserTIMES_ASSIGN      = 61
	ZggParserDIV_ASSIGN        = 62
	ZggParserMOD_ASSIGN        = 63
	ZggParserLOGIC_AND         = 64
	ZggParserLOGIC_OR          = 65
	ZggParserOPTIONAL_CALL     = 66
	ZggParserOPTIONAL_ELSE     = 67
	ZggParserBIT_AND           = 68
	ZggParserBIT_OR            = 69
	ZggParserBIT_NOT           = 70
	ZggParserBIT_SHL           = 71
	ZggParserBIT_SHR           = 72
	ZggParserBIT_XOR           = 73
	ZggParserBIT_AND_ASSIGN    = 74
	ZggParserBIT_OR_ASSIGN     = 75
	ZggParserBIT_SHL_ASSIGN    = 76
	ZggParserBIT_SHR_ASSIGN    = 77
	ZggParserBIT_XOR_ASSIGN    = 78
	ZggParserRANGE_WITHOUT_END = 79
	ZggParserRANGE_WITH_END    = 80
	ZggParserDOT               = 81
	ZggParserCOMMA             = 82
	ZggParserSEMICOLON         = 83
	ZggParserCOLON             = 84
	ZggParserL_PAREN           = 85
	ZggParserR_PAREN           = 86
	ZggParserL_CURLY           = 87
	ZggParserR_CURLY           = 88
	ZggParserL_BRACKET         = 89
	ZggParserR_BRACKET         = 90
	ZggParserLOGIC_NOT         = 91
	ZggParserQUESTION          = 92
	ZggParserGT                = 93
	ZggParserLT                = 94
	ZggParserASSIGN            = 95
	ZggParserPLUS              = 96
	ZggParserMINUS             = 97
	ZggParserTIMES             = 98
	ZggParserDIV               = 99
	ZggParserMOD               = 100
	ZggParserSINGLE_AT         = 101
	ZggParserDOUBLE_AT         = 102
	ZggParserQUOTE             = 103
	ZggParserIDENTIFIER        = 104
	ZggParserTS_RAW            = 105
	ZggParserTS_EXPR_START     = 106
	ZggParserTS_IDENTIFIER     = 107
	ZggParserStrExpr_WS        = 108
)

ZggParser tokens.

View Source 
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

This section is empty.

Functions

func GetModulePath 

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

func SimpleImport 

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

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 added in v1.0.4 

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

func NewArrayComprehensionContext added in v1.0.4 

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

func (*ArrayComprehensionContext) Accept added in v1.0.4 

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

func (*ArrayComprehensionContext) AllExpr added in v1.0.4 

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

func (*ArrayComprehensionContext) AllIDENTIFIER added in v1.0.4 

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

func (*ArrayComprehensionContext) COMMA added in v1.0.4 

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

func (*ArrayComprehensionContext) Expr added in v1.0.4 

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

func (*ArrayComprehensionContext) FOR added in v1.0.4 

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

func (*ArrayComprehensionContext) GetBegin added in v1.0.4 

func (s *ArrayComprehensionContext) GetBegin() IExprContext

func (*ArrayComprehensionContext) GetEnd added in v1.0.4 

func (s *ArrayComprehensionContext) GetEnd() IExprContext

func (*ArrayComprehensionContext) GetFilter added in v1.0.4 

func (s *ArrayComprehensionContext) GetFilter() IExprContext

func (*ArrayComprehensionContext) GetIndexer added in v1.0.4 

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

func (*ArrayComprehensionContext) GetItemExpr added in v1.0.4 

func (s *ArrayComprehensionContext) GetItemExpr() IExprContext

func (*ArrayComprehensionContext) GetRuleContext added in v1.0.4 

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

func (*ArrayComprehensionContext) GetValue added in v1.0.4 

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

func (*ArrayComprehensionContext) IDENTIFIER added in v1.0.4 

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

func (*ArrayComprehensionContext) IF added in v1.0.4 

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

func (*ArrayComprehensionContext) IN added in v1.0.4 

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

func (*ArrayComprehensionContext) L_BRACKET added in v1.0.4 

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

func (*ArrayComprehensionContext) RANGE_WITHOUT_END added in v1.0.4 

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

func (*ArrayComprehensionContext) RANGE_WITH_END added in v1.0.4 

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

func (*ArrayComprehensionContext) R_BRACKET added in v1.0.4 

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

func (*ArrayComprehensionContext) SetBegin added in v1.0.4 

func (s *ArrayComprehensionContext) SetBegin(v IExprContext)

func (*ArrayComprehensionContext) SetEnd added in v1.0.4 

func (s *ArrayComprehensionContext) SetEnd(v IExprContext)

func (*ArrayComprehensionContext) SetFilter added in v1.0.4 

func (s *ArrayComprehensionContext) SetFilter(v IExprContext)

func (*ArrayComprehensionContext) SetIndexer added in v1.0.4 

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

func (*ArrayComprehensionContext) SetItemExpr added in v1.0.4 

func (s *ArrayComprehensionContext) SetItemExpr(v IExprContext)

func (*ArrayComprehensionContext) SetValue added in v1.0.4 

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) Expr 

func (s *ArrayItemContext) Expr() IExprContext

func (*ArrayItemContext) GetParser 

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

func (*ArrayItemContext) GetRuleContext 

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

func (*ArrayItemContext) IsArrayItemContext 

func (*ArrayItemContext) IsArrayItemContext()

func (*ArrayItemContext) MORE_ARGS 

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

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) CopyFrom 

func (s *AssignExprContext) CopyFrom(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 added in v1.0.4 

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) 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) VisitExprIsType added in v1.0.8 

func (v *BaseZggParserVisitor) VisitExprIsType(ctx *ExprIsTypeContext) 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 added in v1.0.4 

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

func (*BaseZggParserVisitor) VisitExprUseCloser added in v1.0.4 

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

func (*BaseZggParserVisitor) VisitExprUseMethod added in v1.0.4 

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) 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) 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 added in v1.0.4 

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) 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 added in v1.0.8 

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 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) CopyFrom 

func (s *ExprContext) CopyFrom(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 ExprIsTypeContext added in v1.0.8 

type ExprIsTypeContext struct {
	*ExprContext
}

func NewExprIsTypeContext added in v1.0.8 

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

func (*ExprIsTypeContext) Accept added in v1.0.8 

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

func (*ExprIsTypeContext) AllExpr added in v1.0.8 

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

func (*ExprIsTypeContext) Expr added in v1.0.8 

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

func (*ExprIsTypeContext) GetRuleContext added in v1.0.8 

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

func (*ExprIsTypeContext) IS added in v1.0.8 

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

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 added in v1.0.4 

type ExprUseBlockContext struct {
	*ExprContext
}

func NewExprUseBlockContext added in v1.0.4 

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

func (*ExprUseBlockContext) Accept added in v1.0.4 

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

func (*ExprUseBlockContext) CodeBlock added in v1.0.4 

func (s *ExprUseBlockContext) CodeBlock() ICodeBlockContext

func (*ExprUseBlockContext) Expr added in v1.0.4 

func (s *ExprUseBlockContext) Expr() IExprContext

func (*ExprUseBlockContext) GetRuleContext added in v1.0.4 

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

func (*ExprUseBlockContext) USE_AT added in v1.0.4 

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

type ExprUseCloserContext added in v1.0.4 

type ExprUseCloserContext struct {
	*ExprContext
}

func NewExprUseCloserContext added in v1.0.4 

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

func (*ExprUseCloserContext) Accept added in v1.0.4 

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

func (*ExprUseCloserContext) Expr added in v1.0.4 

func (s *ExprUseCloserContext) Expr() IExprContext

func (*ExprUseCloserContext) GetRuleContext added in v1.0.4 

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

func (*ExprUseCloserContext) USE added in v1.0.4 

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

type ExprUseMethodContext added in v1.0.4 

type ExprUseMethodContext struct {
	*ExprContext
}

func NewExprUseMethodContext added in v1.0.4 

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

func (*ExprUseMethodContext) Accept added in v1.0.4 

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

func (*ExprUseMethodContext) Expr added in v1.0.4 

func (s *ExprUseMethodContext) Expr() IExprContext

func (*ExprUseMethodContext) GetRuleContext added in v1.0.4 

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

func (*ExprUseMethodContext) IDENTIFIER added in v1.0.4 

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

func (*ExprUseMethodContext) USE_AT added in v1.0.4 

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) GetParser 

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

func (*FuncArgumentContext) GetRuleContext 

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

func (*FuncArgumentContext) IDENTIFIER 

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

func (*FuncArgumentContext) IsFuncArgumentContext 

func (*FuncArgumentContext) IsFuncArgumentContext()

func (*FuncArgumentContext) MORE_ARGS 

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

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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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)

	// 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)

	// 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

	// 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

	// 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

	// 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

	// 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) CopyFrom 

func (s *IntegerContext) CopyFrom(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) CopyFrom 

func (s *KeyValueContext) CopyFrom(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) CopyFrom 

func (s *LiteralContext) CopyFrom(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 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) CopyFrom 

func (s *LvalContext) CopyFrom(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 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) CopyFrom 

func (s *ObjItemContext) CopyFrom(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 added in v1.0.4 

type ObjectComprehensionContext struct {
	*LiteralContext
	// contains filtered or unexported fields
}

func NewObjectComprehensionContext added in v1.0.4 

func NewObjectComprehensionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectComprehensionContext

func (*ObjectComprehensionContext) Accept added in v1.0.4 

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

func (*ObjectComprehensionContext) AllExpr added in v1.0.4 

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

func (*ObjectComprehensionContext) AllIDENTIFIER added in v1.0.4 

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

func (*ObjectComprehensionContext) COLON added in v1.0.4 

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

func (*ObjectComprehensionContext) COMMA added in v1.0.4 

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

func (*ObjectComprehensionContext) Expr added in v1.0.4 

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

func (*ObjectComprehensionContext) FOR added in v1.0.4 

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

func (*ObjectComprehensionContext) GetBegin added in v1.0.4 

func (s *ObjectComprehensionContext) GetBegin() IExprContext

func (*ObjectComprehensionContext) GetEnd added in v1.0.4 

func (s *ObjectComprehensionContext) GetEnd() IExprContext

func (*ObjectComprehensionContext) GetFilter added in v1.0.4 

func (s *ObjectComprehensionContext) GetFilter() IExprContext

func (*ObjectComprehensionContext) GetIndexer added in v1.0.4 

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

func (*ObjectComprehensionContext) GetKeyExpr added in v1.0.4 

func (s *ObjectComprehensionContext) GetKeyExpr() IExprContext

func (*ObjectComprehensionContext) GetRuleContext added in v1.0.4 

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

func (*ObjectComprehensionContext) GetValue added in v1.0.4 

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

func (*ObjectComprehensionContext) GetValueExpr added in v1.0.4 

func (s *ObjectComprehensionContext) GetValueExpr() IExprContext

func (*ObjectComprehensionContext) IDENTIFIER added in v1.0.4 

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

func (*ObjectComprehensionContext) IF added in v1.0.4 

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

func (*ObjectComprehensionContext) IN added in v1.0.4 

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

func (*ObjectComprehensionContext) L_CURLY added in v1.0.4 

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

func (*ObjectComprehensionContext) RANGE_WITHOUT_END added in v1.0.4 

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

func (*ObjectComprehensionContext) RANGE_WITH_END added in v1.0.4 

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

func (*ObjectComprehensionContext) R_CURLY added in v1.0.4 

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

func (*ObjectComprehensionContext) SetBegin added in v1.0.4 

func (s *ObjectComprehensionContext) SetBegin(v IExprContext)

func (*ObjectComprehensionContext) SetEnd added in v1.0.4 

func (s *ObjectComprehensionContext) SetEnd(v IExprContext)

func (*ObjectComprehensionContext) SetFilter added in v1.0.4 

func (s *ObjectComprehensionContext) SetFilter(v IExprContext)

func (*ObjectComprehensionContext) SetIndexer added in v1.0.4 

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

func (*ObjectComprehensionContext) SetKeyExpr added in v1.0.4 

func (s *ObjectComprehensionContext) SetKeyExpr(v IExprContext)

func (*ObjectComprehensionContext) SetValue added in v1.0.4 

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

func (*ObjectComprehensionContext) SetValueExpr added in v1.0.4 

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 added in v1.0.4 

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) 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) VisitExprIsType added in v1.0.8 

func (v *ParseVisitor) VisitExprIsType(ctx *ExprIsTypeContext) 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 added in v1.0.4 

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

func (*ParseVisitor) VisitExprUseCloser added in v1.0.4 

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

func (*ParseVisitor) VisitExprUseMethod added in v1.0.4 

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) 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) 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 added in v1.0.4 

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) 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 added in v1.0.8 

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) CopyFrom 

func (s *ReplItemContext) CopyFrom(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) CopyFrom 

func (s *StmtContext) CopyFrom(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 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 added in v1.0.4 

func (s *StmtForEachContext) GetIdIndex() antlr.Token

func (*StmtForEachContext) GetIdValue added in v1.0.4 

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 added in v1.0.4 

func (s *StmtForEachContext) SetIdIndex(v antlr.Token)

func (*StmtForEachContext) SetIdValue added in v1.0.4 

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 added in v1.0.11 

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 added in v1.0.12 

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) CopyFrom 

func (s *TsItemContext) CopyFrom(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) CopyFrom 

func (s *WhenConditionContext) CopyFrom(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 added in v1.0.4 

func (s *WhenConditionInRangeContext) GetLowerBound() IExprContext

func (*WhenConditionInRangeContext) GetRuleContext 

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

func (*WhenConditionInRangeContext) GetUpperBound added in v1.0.4 

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 added in v1.0.4 

func (s *WhenConditionInRangeContext) SetLowerBound(v IExprContext)

func (*WhenConditionInRangeContext) SetUpperBound added in v1.0.4 

func (s *WhenConditionInRangeContext) SetUpperBound(v IExprContext)

type WhenConditionIsTypeContext added in v1.0.8 

type WhenConditionIsTypeContext struct {
	*WhenConditionContext
}

func NewWhenConditionIsTypeContext added in v1.0.8 

func NewWhenConditionIsTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhenConditionIsTypeContext

func (*WhenConditionIsTypeContext) Accept added in v1.0.8 

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

func (*WhenConditionIsTypeContext) Expr added in v1.0.8 

func (s *WhenConditionIsTypeContext) Expr() IExprContext

func (*WhenConditionIsTypeContext) GetRuleContext added in v1.0.8 

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

func (*WhenConditionIsTypeContext) IS added in v1.0.8 

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

type ZggParser 

type ZggParser struct {
	ZggBaseParser
}

func NewZggParser 

func NewZggParser(input antlr.TokenStream) *ZggParser

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#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#exprAssign.
	VisitExprAssign(ctx *ExprAssignContext) 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#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#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#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#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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.