freemarkerparser

package
v1.3.7-beta5 Latest Latest
Warning

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

 Go to latest Published: Nov 8, 2024 License: AGPL-3.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	FreemarkerLexerCOMMENT               = 1
	FreemarkerLexerSTART_DIRECTIVE_TAG   = 2
	FreemarkerLexerEND_DIRECTIVE_TAG     = 3
	FreemarkerLexerSTART_USER_DIR_TAG    = 4
	FreemarkerLexerEND_USER_DIR_TAG      = 5
	FreemarkerLexerINLINE_EXPR_START     = 6
	FreemarkerLexerCONTENT               = 7
	FreemarkerLexerDQS_EXIT              = 8
	FreemarkerLexerDQS_ESCAPE            = 9
	FreemarkerLexerDQS_ENTER_EXPR        = 10
	FreemarkerLexerDQS_CONTENT           = 11
	FreemarkerLexerSQS_EXIT              = 12
	FreemarkerLexerSQS_ESCAPE            = 13
	FreemarkerLexerSQS_ENTER_EXPR        = 14
	FreemarkerLexerSQS_CONTENT           = 15
	FreemarkerLexerEXPR_IF               = 16
	FreemarkerLexerEXPR_ELSE             = 17
	FreemarkerLexerEXPR_ELSEIF           = 18
	FreemarkerLexerEXPR_ASSIGN           = 19
	FreemarkerLexerEXPR_AS               = 20
	FreemarkerLexerEXPR_LIST             = 21
	FreemarkerLexerEXPR_TRUE             = 22
	FreemarkerLexerEXPR_FALSE            = 23
	FreemarkerLexerEXPR_INCLUDE          = 24
	FreemarkerLexerEXPR_IMPORT           = 25
	FreemarkerLexerEXPR_MACRO            = 26
	FreemarkerLexerEXPR_NESTED           = 27
	FreemarkerLexerEXPR_RETURN           = 28
	FreemarkerLexerEXPR_LT_SYM           = 29
	FreemarkerLexerEXPR_LT_STR           = 30
	FreemarkerLexerEXPR_LTE_SYM          = 31
	FreemarkerLexerEXPR_LTE_STR          = 32
	FreemarkerLexerEXPR_GT_STR           = 33
	FreemarkerLexerEXPR_GTE_SYM          = 34
	FreemarkerLexerEXPR_GTE_STR          = 35
	FreemarkerLexerEXPR_NUM              = 36
	FreemarkerLexerEXPR_EXIT_R_BRACE     = 37
	FreemarkerLexerEXPR_EXIT_GT          = 38
	FreemarkerLexerEXPR_EXIT_DIV_GT      = 39
	FreemarkerLexerEXPR_WS               = 40
	FreemarkerLexerEXPR_COMENT           = 41
	FreemarkerLexerEXPR_STRUCT           = 42
	FreemarkerLexerEXPR_DOUBLE_STR_START = 43
	FreemarkerLexerEXPR_SINGLE_STR_START = 44
	FreemarkerLexerEXPR_AT               = 45
	FreemarkerLexerEXPR_DBL_QUESTION     = 46
	FreemarkerLexerEXPR_QUESTION         = 47
	FreemarkerLexerEXPR_BANG             = 48
	FreemarkerLexerEXPR_ADD              = 49
	FreemarkerLexerEXPR_SUB              = 50
	FreemarkerLexerEXPR_MUL              = 51
	FreemarkerLexerEXPR_DIV              = 52
	FreemarkerLexerEXPR_MOD              = 53
	FreemarkerLexerEXPR_L_PAREN          = 54
	FreemarkerLexerEXPR_R_PAREN          = 55
	FreemarkerLexerEXPR_L_SQ_PAREN       = 56
	FreemarkerLexerEXPR_R_SQ_PAREN       = 57
	FreemarkerLexerEXPR_COMPARE_EQ       = 58
	FreemarkerLexerEXPR_EQ               = 59
	FreemarkerLexerEXPR_COMPARE_NEQ      = 60
	FreemarkerLexerEXPR_LOGICAL_AND      = 61
	FreemarkerLexerEXPR_LOGICAL_OR       = 62
	FreemarkerLexerEXPR_DOT              = 63
	FreemarkerLexerEXPR_COMMA            = 64
	FreemarkerLexerEXPR_COLON            = 65
	FreemarkerLexerEXPR_SEMICOLON        = 66
	FreemarkerLexerEXPR_SYMBOL           = 67
)

FreemarkerLexer tokens.

View Source 
const (
	FreemarkerLexerDOUBLE_QUOTE_STRING_MODE = iota + 1
	FreemarkerLexerSINGLE_QUOTE_STRING_MODE
	FreemarkerLexerEXPR_MODE
)

FreemarkerLexer modes.

View Source 
const (
	FreemarkerParserEOF                   = antlr.TokenEOF
	FreemarkerParserCOMMENT               = 1
	FreemarkerParserSTART_DIRECTIVE_TAG   = 2
	FreemarkerParserEND_DIRECTIVE_TAG     = 3
	FreemarkerParserSTART_USER_DIR_TAG    = 4
	FreemarkerParserEND_USER_DIR_TAG      = 5
	FreemarkerParserINLINE_EXPR_START     = 6
	FreemarkerParserCONTENT               = 7
	FreemarkerParserDQS_EXIT              = 8
	FreemarkerParserDQS_ESCAPE            = 9
	FreemarkerParserDQS_ENTER_EXPR        = 10
	FreemarkerParserDQS_CONTENT           = 11
	FreemarkerParserSQS_EXIT              = 12
	FreemarkerParserSQS_ESCAPE            = 13
	FreemarkerParserSQS_ENTER_EXPR        = 14
	FreemarkerParserSQS_CONTENT           = 15
	FreemarkerParserEXPR_IF               = 16
	FreemarkerParserEXPR_ELSE             = 17
	FreemarkerParserEXPR_ELSEIF           = 18
	FreemarkerParserEXPR_ASSIGN           = 19
	FreemarkerParserEXPR_AS               = 20
	FreemarkerParserEXPR_LIST             = 21
	FreemarkerParserEXPR_TRUE             = 22
	FreemarkerParserEXPR_FALSE            = 23
	FreemarkerParserEXPR_INCLUDE          = 24
	FreemarkerParserEXPR_IMPORT           = 25
	FreemarkerParserEXPR_MACRO            = 26
	FreemarkerParserEXPR_NESTED           = 27
	FreemarkerParserEXPR_RETURN           = 28
	FreemarkerParserEXPR_LT_SYM           = 29
	FreemarkerParserEXPR_LT_STR           = 30
	FreemarkerParserEXPR_LTE_SYM          = 31
	FreemarkerParserEXPR_LTE_STR          = 32
	FreemarkerParserEXPR_GT_STR           = 33
	FreemarkerParserEXPR_GTE_SYM          = 34
	FreemarkerParserEXPR_GTE_STR          = 35
	FreemarkerParserEXPR_NUM              = 36
	FreemarkerParserEXPR_EXIT_R_BRACE     = 37
	FreemarkerParserEXPR_EXIT_GT          = 38
	FreemarkerParserEXPR_EXIT_DIV_GT      = 39
	FreemarkerParserEXPR_WS               = 40
	FreemarkerParserEXPR_COMENT           = 41
	FreemarkerParserEXPR_STRUCT           = 42
	FreemarkerParserEXPR_DOUBLE_STR_START = 43
	FreemarkerParserEXPR_SINGLE_STR_START = 44
	FreemarkerParserEXPR_AT               = 45
	FreemarkerParserEXPR_DBL_QUESTION     = 46
	FreemarkerParserEXPR_QUESTION         = 47
	FreemarkerParserEXPR_BANG             = 48
	FreemarkerParserEXPR_ADD              = 49
	FreemarkerParserEXPR_SUB              = 50
	FreemarkerParserEXPR_MUL              = 51
	FreemarkerParserEXPR_DIV              = 52
	FreemarkerParserEXPR_MOD              = 53
	FreemarkerParserEXPR_L_PAREN          = 54
	FreemarkerParserEXPR_R_PAREN          = 55
	FreemarkerParserEXPR_L_SQ_PAREN       = 56
	FreemarkerParserEXPR_R_SQ_PAREN       = 57
	FreemarkerParserEXPR_COMPARE_EQ       = 58
	FreemarkerParserEXPR_EQ               = 59
	FreemarkerParserEXPR_COMPARE_NEQ      = 60
	FreemarkerParserEXPR_LOGICAL_AND      = 61
	FreemarkerParserEXPR_LOGICAL_OR       = 62
	FreemarkerParserEXPR_DOT              = 63
	FreemarkerParserEXPR_COMMA            = 64
	FreemarkerParserEXPR_COLON            = 65
	FreemarkerParserEXPR_SEMICOLON        = 66
	FreemarkerParserEXPR_SYMBOL           = 67
)

FreemarkerParser tokens.

View Source 
const (
	FreemarkerParserRULE_template                  = 0
	FreemarkerParserRULE_elements                  = 1
	FreemarkerParserRULE_element                   = 2
	FreemarkerParserRULE_rawText                   = 3
	FreemarkerParserRULE_directive                 = 4
	FreemarkerParserRULE_directiveIf               = 5
	FreemarkerParserRULE_directiveIfTrueElements   = 6
	FreemarkerParserRULE_directiveIfElseIfElements = 7
	FreemarkerParserRULE_directiveIfElseElements   = 8
	FreemarkerParserRULE_tagExprElseIfs            = 9
	FreemarkerParserRULE_directiveAssign           = 10
	FreemarkerParserRULE_directiveList             = 11
	FreemarkerParserRULE_directiveListBodyElements = 12
	FreemarkerParserRULE_directiveListElseElements = 13
	FreemarkerParserRULE_directiveInclude          = 14
	FreemarkerParserRULE_directiveImport           = 15
	FreemarkerParserRULE_directiveMacro            = 16
	FreemarkerParserRULE_directiveNested           = 17
	FreemarkerParserRULE_directiveReturn           = 18
	FreemarkerParserRULE_directiveUser             = 19
	FreemarkerParserRULE_directiveUserId           = 20
	FreemarkerParserRULE_directiveUserParams       = 21
	FreemarkerParserRULE_directiveUserLoopParams   = 22
	FreemarkerParserRULE_tagExpr                   = 23
	FreemarkerParserRULE_inlineExpr                = 24
	FreemarkerParserRULE_string                    = 25
	FreemarkerParserRULE_expr                      = 26
	FreemarkerParserRULE_functionParams            = 27
	FreemarkerParserRULE_booleanRelationalOperator = 28
	FreemarkerParserRULE_struct                    = 29
	FreemarkerParserRULE_struct_pair               = 30
	FreemarkerParserRULE_single_quote_string       = 31
	FreemarkerParserRULE_double_quote_string       = 32
)

FreemarkerParser rules.

Variables

This section is empty.

Functions

func FreemarkerLexerInit 

func FreemarkerLexerInit()

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

func FreemarkerParserInit 

func FreemarkerParserInit()

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

Types

type BaseFreemarkerParserVisitor 

type BaseFreemarkerParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseFreemarkerParserVisitor) VisitBoolExpr 

func (v *BaseFreemarkerParserVisitor) VisitBoolExpr(ctx *BoolExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitBooleanRelationalOperator 

func (v *BaseFreemarkerParserVisitor) VisitBooleanRelationalOperator(ctx *BooleanRelationalOperatorContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirective 

func (v *BaseFreemarkerParserVisitor) VisitDirective(ctx *DirectiveContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveAssign 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveAssign(ctx *DirectiveAssignContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveElement 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveElement(ctx *DirectiveElementContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveIf 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveIf(ctx *DirectiveIfContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveIfElseElements 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveIfElseElements(ctx *DirectiveIfElseElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveIfElseIfElements 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveIfElseIfElements(ctx *DirectiveIfElseIfElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveIfTrueElements 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveIfTrueElements(ctx *DirectiveIfTrueElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveImport 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveImport(ctx *DirectiveImportContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveInclude 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveInclude(ctx *DirectiveIncludeContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveList 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveList(ctx *DirectiveListContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveListBodyElements 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveListBodyElements(ctx *DirectiveListBodyElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveListElseElements 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveListElseElements(ctx *DirectiveListElseElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveMacro 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveMacro(ctx *DirectiveMacroContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveNested 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveNested(ctx *DirectiveNestedContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveReturn 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveReturn(ctx *DirectiveReturnContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveUser 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveUser(ctx *DirectiveUserContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveUserId 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveUserId(ctx *DirectiveUserIdContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveUserLoopParams 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveUserLoopParams(ctx *DirectiveUserLoopParamsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDirectiveUserParams 

func (v *BaseFreemarkerParserVisitor) VisitDirectiveUserParams(ctx *DirectiveUserParamsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDoubleQuote 

func (v *BaseFreemarkerParserVisitor) VisitDoubleQuote(ctx *DoubleQuoteContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitDouble_quote_string 

func (v *BaseFreemarkerParserVisitor) VisitDouble_quote_string(ctx *Double_quote_stringContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitElements 

func (v *BaseFreemarkerParserVisitor) VisitElements(ctx *ElementsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprAddSub 

func (v *BaseFreemarkerParserVisitor) VisitExprAddSub(ctx *ExprAddSubContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprBoolAnd 

func (v *BaseFreemarkerParserVisitor) VisitExprBoolAnd(ctx *ExprBoolAndContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprBoolEq 

func (v *BaseFreemarkerParserVisitor) VisitExprBoolEq(ctx *ExprBoolEqContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprBoolOr 

func (v *BaseFreemarkerParserVisitor) VisitExprBoolOr(ctx *ExprBoolOrContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprBoolRelational 

func (v *BaseFreemarkerParserVisitor) VisitExprBoolRelational(ctx *ExprBoolRelationalContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprBuiltIn 

func (v *BaseFreemarkerParserVisitor) VisitExprBuiltIn(ctx *ExprBuiltInContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprDefault 

func (v *BaseFreemarkerParserVisitor) VisitExprDefault(ctx *ExprDefaultContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprDotAccess 

func (v *BaseFreemarkerParserVisitor) VisitExprDotAccess(ctx *ExprDotAccessContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprFunctionCall 

func (v *BaseFreemarkerParserVisitor) VisitExprFunctionCall(ctx *ExprFunctionCallContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprMissingTest 

func (v *BaseFreemarkerParserVisitor) VisitExprMissingTest(ctx *ExprMissingTestContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprMulDivMod 

func (v *BaseFreemarkerParserVisitor) VisitExprMulDivMod(ctx *ExprMulDivModContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprRoundParentheses 

func (v *BaseFreemarkerParserVisitor) VisitExprRoundParentheses(ctx *ExprRoundParenthesesContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprSquareParentheses 

func (v *BaseFreemarkerParserVisitor) VisitExprSquareParentheses(ctx *ExprSquareParenthesesContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitExprUnaryOp 

func (v *BaseFreemarkerParserVisitor) VisitExprUnaryOp(ctx *ExprUnaryOpContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitFunctionParams 

func (v *BaseFreemarkerParserVisitor) VisitFunctionParams(ctx *FunctionParamsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitInlineExpr 

func (v *BaseFreemarkerParserVisitor) VisitInlineExpr(ctx *InlineExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitInlineExprElement 

func (v *BaseFreemarkerParserVisitor) VisitInlineExprElement(ctx *InlineExprElementContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitNumberExpr 

func (v *BaseFreemarkerParserVisitor) VisitNumberExpr(ctx *NumberExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitRawText 

func (v *BaseFreemarkerParserVisitor) VisitRawText(ctx *RawTextContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitRawTextElement 

func (v *BaseFreemarkerParserVisitor) VisitRawTextElement(ctx *RawTextElementContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitSingleQuote 

func (v *BaseFreemarkerParserVisitor) VisitSingleQuote(ctx *SingleQuoteContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitSingle_quote_string 

func (v *BaseFreemarkerParserVisitor) VisitSingle_quote_string(ctx *Single_quote_stringContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitStringExpr 

func (v *BaseFreemarkerParserVisitor) VisitStringExpr(ctx *StringExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitStruct 

func (v *BaseFreemarkerParserVisitor) VisitStruct(ctx *StructContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitStructExpr 

func (v *BaseFreemarkerParserVisitor) VisitStructExpr(ctx *StructExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitStruct_pair 

func (v *BaseFreemarkerParserVisitor) VisitStruct_pair(ctx *Struct_pairContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitSymbolExpr 

func (v *BaseFreemarkerParserVisitor) VisitSymbolExpr(ctx *SymbolExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitTagExpr 

func (v *BaseFreemarkerParserVisitor) VisitTagExpr(ctx *TagExprContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitTagExprElseIfs 

func (v *BaseFreemarkerParserVisitor) VisitTagExprElseIfs(ctx *TagExprElseIfsContext) interface{}

func (*BaseFreemarkerParserVisitor) VisitTemplate 

func (v *BaseFreemarkerParserVisitor) VisitTemplate(ctx *TemplateContext) interface{}

type BoolExprContext 

type BoolExprContext struct {
	*ExprContext
}

func NewBoolExprContext 

func NewBoolExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolExprContext

func (*BoolExprContext) Accept 

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

func (*BoolExprContext) EXPR_FALSE 

func (s *BoolExprContext) EXPR_FALSE() antlr.TerminalNode

func (*BoolExprContext) EXPR_TRUE 

func (s *BoolExprContext) EXPR_TRUE() antlr.TerminalNode

func (*BoolExprContext) GetRuleContext 

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

type BooleanRelationalOperatorContext 

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

func NewBooleanRelationalOperatorContext 

func NewBooleanRelationalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanRelationalOperatorContext

func NewEmptyBooleanRelationalOperatorContext 

func NewEmptyBooleanRelationalOperatorContext() *BooleanRelationalOperatorContext

func (*BooleanRelationalOperatorContext) Accept 

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

func (*BooleanRelationalOperatorContext) EXPR_GTE_STR 

func (s *BooleanRelationalOperatorContext) EXPR_GTE_STR() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_GTE_SYM 

func (s *BooleanRelationalOperatorContext) EXPR_GTE_SYM() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_GT_STR 

func (s *BooleanRelationalOperatorContext) EXPR_GT_STR() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_LTE_STR 

func (s *BooleanRelationalOperatorContext) EXPR_LTE_STR() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_LTE_SYM 

func (s *BooleanRelationalOperatorContext) EXPR_LTE_SYM() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_LT_STR 

func (s *BooleanRelationalOperatorContext) EXPR_LT_STR() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) EXPR_LT_SYM 

func (s *BooleanRelationalOperatorContext) EXPR_LT_SYM() antlr.TerminalNode

func (*BooleanRelationalOperatorContext) GetParser 

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

func (*BooleanRelationalOperatorContext) GetRuleContext 

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

func (*BooleanRelationalOperatorContext) IsBooleanRelationalOperatorContext 

func (*BooleanRelationalOperatorContext) IsBooleanRelationalOperatorContext()

func (*BooleanRelationalOperatorContext) ToStringTree 

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

type DirectiveAssignContext 

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

func NewDirectiveAssignContext 

func NewDirectiveAssignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveAssignContext

func NewEmptyDirectiveAssignContext 

func NewEmptyDirectiveAssignContext() *DirectiveAssignContext

func (*DirectiveAssignContext) Accept 

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

func (*DirectiveAssignContext) AllEXPR_ASSIGN 

func (s *DirectiveAssignContext) AllEXPR_ASSIGN() []antlr.TerminalNode

func (*DirectiveAssignContext) AllEXPR_EXIT_GT 

func (s *DirectiveAssignContext) AllEXPR_EXIT_GT() []antlr.TerminalNode

func (*DirectiveAssignContext) END_DIRECTIVE_TAG 

func (s *DirectiveAssignContext) END_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveAssignContext) EXPR_ASSIGN 

func (s *DirectiveAssignContext) EXPR_ASSIGN(i int) antlr.TerminalNode

func (*DirectiveAssignContext) EXPR_EQ 

func (s *DirectiveAssignContext) EXPR_EQ() antlr.TerminalNode

func (*DirectiveAssignContext) EXPR_EXIT_DIV_GT 

func (s *DirectiveAssignContext) EXPR_EXIT_DIV_GT() antlr.TerminalNode

func (*DirectiveAssignContext) EXPR_EXIT_GT 

func (s *DirectiveAssignContext) EXPR_EXIT_GT(i int) antlr.TerminalNode

func (*DirectiveAssignContext) EXPR_SYMBOL 

func (s *DirectiveAssignContext) EXPR_SYMBOL() antlr.TerminalNode

func (*DirectiveAssignContext) Elements 

func (s *DirectiveAssignContext) Elements() IElementsContext

func (*DirectiveAssignContext) GetParser 

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

func (*DirectiveAssignContext) GetRuleContext 

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

func (*DirectiveAssignContext) IsDirectiveAssignContext 

func (*DirectiveAssignContext) IsDirectiveAssignContext()

func (*DirectiveAssignContext) START_DIRECTIVE_TAG 

func (s *DirectiveAssignContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveAssignContext) TagExpr 

func (s *DirectiveAssignContext) TagExpr() ITagExprContext

func (*DirectiveAssignContext) ToStringTree 

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

type DirectiveContext 

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

func NewDirectiveContext 

func NewDirectiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveContext

func NewEmptyDirectiveContext 

func NewEmptyDirectiveContext() *DirectiveContext

func (*DirectiveContext) Accept 

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

func (*DirectiveContext) DirectiveAssign 

func (s *DirectiveContext) DirectiveAssign() IDirectiveAssignContext

func (*DirectiveContext) DirectiveIf 

func (s *DirectiveContext) DirectiveIf() IDirectiveIfContext

func (*DirectiveContext) DirectiveImport 

func (s *DirectiveContext) DirectiveImport() IDirectiveImportContext

func (*DirectiveContext) DirectiveInclude 

func (s *DirectiveContext) DirectiveInclude() IDirectiveIncludeContext

func (*DirectiveContext) DirectiveList 

func (s *DirectiveContext) DirectiveList() IDirectiveListContext

func (*DirectiveContext) DirectiveMacro 

func (s *DirectiveContext) DirectiveMacro() IDirectiveMacroContext

func (*DirectiveContext) DirectiveNested 

func (s *DirectiveContext) DirectiveNested() IDirectiveNestedContext

func (*DirectiveContext) DirectiveReturn 

func (s *DirectiveContext) DirectiveReturn() IDirectiveReturnContext

func (*DirectiveContext) DirectiveUser 

func (s *DirectiveContext) DirectiveUser() IDirectiveUserContext

func (*DirectiveContext) GetParser 

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

func (*DirectiveContext) GetRuleContext 

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

func (*DirectiveContext) IsDirectiveContext 

func (*DirectiveContext) IsDirectiveContext()

func (*DirectiveContext) ToStringTree 

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

type DirectiveElementContext 

type DirectiveElementContext struct {
	*ElementContext
}

func NewDirectiveElementContext 

func NewDirectiveElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DirectiveElementContext

func (*DirectiveElementContext) Accept 

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

func (*DirectiveElementContext) Directive 

func (s *DirectiveElementContext) Directive() IDirectiveContext

func (*DirectiveElementContext) GetRuleContext 

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

type DirectiveIfContext 

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

func NewDirectiveIfContext 

func NewDirectiveIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveIfContext

func NewEmptyDirectiveIfContext 

func NewEmptyDirectiveIfContext() *DirectiveIfContext

func (*DirectiveIfContext) Accept 

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

func (*DirectiveIfContext) AllDirectiveIfElseIfElements 

func (s *DirectiveIfContext) AllDirectiveIfElseIfElements() []IDirectiveIfElseIfElementsContext

func (*DirectiveIfContext) AllEXPR_ELSEIF 

func (s *DirectiveIfContext) AllEXPR_ELSEIF() []antlr.TerminalNode

func (*DirectiveIfContext) AllEXPR_EXIT_GT 

func (s *DirectiveIfContext) AllEXPR_EXIT_GT() []antlr.TerminalNode

func (*DirectiveIfContext) AllEXPR_IF 

func (s *DirectiveIfContext) AllEXPR_IF() []antlr.TerminalNode

func (*DirectiveIfContext) AllSTART_DIRECTIVE_TAG 

func (s *DirectiveIfContext) AllSTART_DIRECTIVE_TAG() []antlr.TerminalNode

func (*DirectiveIfContext) AllTagExprElseIfs 

func (s *DirectiveIfContext) AllTagExprElseIfs() []ITagExprElseIfsContext

func (*DirectiveIfContext) DirectiveIfElseElements 

func (s *DirectiveIfContext) DirectiveIfElseElements() IDirectiveIfElseElementsContext

func (*DirectiveIfContext) DirectiveIfElseIfElements 

func (s *DirectiveIfContext) DirectiveIfElseIfElements(i int) IDirectiveIfElseIfElementsContext

func (*DirectiveIfContext) DirectiveIfTrueElements 

func (s *DirectiveIfContext) DirectiveIfTrueElements() IDirectiveIfTrueElementsContext

func (*DirectiveIfContext) END_DIRECTIVE_TAG 

func (s *DirectiveIfContext) END_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveIfContext) EXPR_ELSE 

func (s *DirectiveIfContext) EXPR_ELSE() antlr.TerminalNode

func (*DirectiveIfContext) EXPR_ELSEIF 

func (s *DirectiveIfContext) EXPR_ELSEIF(i int) antlr.TerminalNode

func (*DirectiveIfContext) EXPR_EXIT_GT 

func (s *DirectiveIfContext) EXPR_EXIT_GT(i int) antlr.TerminalNode

func (*DirectiveIfContext) EXPR_IF 

func (s *DirectiveIfContext) EXPR_IF(i int) antlr.TerminalNode

func (*DirectiveIfContext) GetParser 

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

func (*DirectiveIfContext) GetRuleContext 

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

func (*DirectiveIfContext) IsDirectiveIfContext 

func (*DirectiveIfContext) IsDirectiveIfContext()

func (*DirectiveIfContext) START_DIRECTIVE_TAG 

func (s *DirectiveIfContext) START_DIRECTIVE_TAG(i int) antlr.TerminalNode

func (*DirectiveIfContext) TagExpr 

func (s *DirectiveIfContext) TagExpr() ITagExprContext

func (*DirectiveIfContext) TagExprElseIfs 

func (s *DirectiveIfContext) TagExprElseIfs(i int) ITagExprElseIfsContext

func (*DirectiveIfContext) ToStringTree 

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

type DirectiveIfElseElementsContext 

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

func NewDirectiveIfElseElementsContext 

func NewDirectiveIfElseElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveIfElseElementsContext

func NewEmptyDirectiveIfElseElementsContext 

func NewEmptyDirectiveIfElseElementsContext() *DirectiveIfElseElementsContext

func (*DirectiveIfElseElementsContext) Accept 

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

func (*DirectiveIfElseElementsContext) Elements 

func (s *DirectiveIfElseElementsContext) Elements() IElementsContext

func (*DirectiveIfElseElementsContext) GetParser 

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

func (*DirectiveIfElseElementsContext) GetRuleContext 

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

func (*DirectiveIfElseElementsContext) IsDirectiveIfElseElementsContext 

func (*DirectiveIfElseElementsContext) IsDirectiveIfElseElementsContext()

func (*DirectiveIfElseElementsContext) ToStringTree 

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

type DirectiveIfElseIfElementsContext 

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

func NewDirectiveIfElseIfElementsContext 

func NewDirectiveIfElseIfElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveIfElseIfElementsContext

func NewEmptyDirectiveIfElseIfElementsContext 

func NewEmptyDirectiveIfElseIfElementsContext() *DirectiveIfElseIfElementsContext

func (*DirectiveIfElseIfElementsContext) Accept 

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

func (*DirectiveIfElseIfElementsContext) Elements 

func (s *DirectiveIfElseIfElementsContext) Elements() IElementsContext

func (*DirectiveIfElseIfElementsContext) GetParser 

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

func (*DirectiveIfElseIfElementsContext) GetRuleContext 

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

func (*DirectiveIfElseIfElementsContext) IsDirectiveIfElseIfElementsContext 

func (*DirectiveIfElseIfElementsContext) IsDirectiveIfElseIfElementsContext()

func (*DirectiveIfElseIfElementsContext) ToStringTree 

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

type DirectiveIfTrueElementsContext 

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

func NewDirectiveIfTrueElementsContext 

func NewDirectiveIfTrueElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveIfTrueElementsContext

func NewEmptyDirectiveIfTrueElementsContext 

func NewEmptyDirectiveIfTrueElementsContext() *DirectiveIfTrueElementsContext

func (*DirectiveIfTrueElementsContext) Accept 

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

func (*DirectiveIfTrueElementsContext) Elements 

func (s *DirectiveIfTrueElementsContext) Elements() IElementsContext

func (*DirectiveIfTrueElementsContext) GetParser 

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

func (*DirectiveIfTrueElementsContext) GetRuleContext 

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

func (*DirectiveIfTrueElementsContext) IsDirectiveIfTrueElementsContext 

func (*DirectiveIfTrueElementsContext) IsDirectiveIfTrueElementsContext()

func (*DirectiveIfTrueElementsContext) ToStringTree 

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

type DirectiveImportContext 

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

func NewDirectiveImportContext 

func NewDirectiveImportContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveImportContext

func NewEmptyDirectiveImportContext 

func NewEmptyDirectiveImportContext() *DirectiveImportContext

func (*DirectiveImportContext) Accept 

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

func (*DirectiveImportContext) EXPR_AS 

func (s *DirectiveImportContext) EXPR_AS() antlr.TerminalNode

func (*DirectiveImportContext) EXPR_EXIT_GT 

func (s *DirectiveImportContext) EXPR_EXIT_GT() antlr.TerminalNode

func (*DirectiveImportContext) EXPR_IMPORT 

func (s *DirectiveImportContext) EXPR_IMPORT() antlr.TerminalNode

func (*DirectiveImportContext) EXPR_SYMBOL 

func (s *DirectiveImportContext) EXPR_SYMBOL() antlr.TerminalNode

func (*DirectiveImportContext) GetParser 

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

func (*DirectiveImportContext) GetRuleContext 

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

func (*DirectiveImportContext) IsDirectiveImportContext 

func (*DirectiveImportContext) IsDirectiveImportContext()

func (*DirectiveImportContext) START_DIRECTIVE_TAG 

func (s *DirectiveImportContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveImportContext) String_ 

func (s *DirectiveImportContext) String_() IStringContext

func (*DirectiveImportContext) ToStringTree 

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

type DirectiveIncludeContext 

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

func NewDirectiveIncludeContext 

func NewDirectiveIncludeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveIncludeContext

func NewEmptyDirectiveIncludeContext 

func NewEmptyDirectiveIncludeContext() *DirectiveIncludeContext

func (*DirectiveIncludeContext) Accept 

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

func (*DirectiveIncludeContext) EXPR_EXIT_GT 

func (s *DirectiveIncludeContext) EXPR_EXIT_GT() antlr.TerminalNode

func (*DirectiveIncludeContext) EXPR_INCLUDE 

func (s *DirectiveIncludeContext) EXPR_INCLUDE() antlr.TerminalNode

func (*DirectiveIncludeContext) GetParser 

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

func (*DirectiveIncludeContext) GetRuleContext 

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

func (*DirectiveIncludeContext) IsDirectiveIncludeContext 

func (*DirectiveIncludeContext) IsDirectiveIncludeContext()

func (*DirectiveIncludeContext) START_DIRECTIVE_TAG 

func (s *DirectiveIncludeContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveIncludeContext) String_ 

func (s *DirectiveIncludeContext) String_() IStringContext

func (*DirectiveIncludeContext) ToStringTree 

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

type DirectiveListBodyElementsContext 

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

func NewDirectiveListBodyElementsContext 

func NewDirectiveListBodyElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveListBodyElementsContext

func NewEmptyDirectiveListBodyElementsContext 

func NewEmptyDirectiveListBodyElementsContext() *DirectiveListBodyElementsContext

func (*DirectiveListBodyElementsContext) Accept 

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

func (*DirectiveListBodyElementsContext) Elements 

func (s *DirectiveListBodyElementsContext) Elements() IElementsContext

func (*DirectiveListBodyElementsContext) GetParser 

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

func (*DirectiveListBodyElementsContext) GetRuleContext 

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

func (*DirectiveListBodyElementsContext) IsDirectiveListBodyElementsContext 

func (*DirectiveListBodyElementsContext) IsDirectiveListBodyElementsContext()

func (*DirectiveListBodyElementsContext) ToStringTree 

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

type DirectiveListContext 

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

func NewDirectiveListContext 

func NewDirectiveListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveListContext

func NewEmptyDirectiveListContext 

func NewEmptyDirectiveListContext() *DirectiveListContext

func (*DirectiveListContext) Accept 

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

func (*DirectiveListContext) AllEXPR_EXIT_GT 

func (s *DirectiveListContext) AllEXPR_EXIT_GT() []antlr.TerminalNode

func (*DirectiveListContext) AllEXPR_LIST 

func (s *DirectiveListContext) AllEXPR_LIST() []antlr.TerminalNode

func (*DirectiveListContext) AllEXPR_SYMBOL 

func (s *DirectiveListContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*DirectiveListContext) AllSTART_DIRECTIVE_TAG 

func (s *DirectiveListContext) AllSTART_DIRECTIVE_TAG() []antlr.TerminalNode

func (*DirectiveListContext) DirectiveListBodyElements 

func (s *DirectiveListContext) DirectiveListBodyElements() IDirectiveListBodyElementsContext

func (*DirectiveListContext) DirectiveListElseElements 

func (s *DirectiveListContext) DirectiveListElseElements() IDirectiveListElseElementsContext

func (*DirectiveListContext) END_DIRECTIVE_TAG 

func (s *DirectiveListContext) END_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveListContext) EXPR_AS 

func (s *DirectiveListContext) EXPR_AS() antlr.TerminalNode

func (*DirectiveListContext) EXPR_COMMA 

func (s *DirectiveListContext) EXPR_COMMA() antlr.TerminalNode

func (*DirectiveListContext) EXPR_ELSE 

func (s *DirectiveListContext) EXPR_ELSE() antlr.TerminalNode

func (*DirectiveListContext) EXPR_EXIT_GT 

func (s *DirectiveListContext) EXPR_EXIT_GT(i int) antlr.TerminalNode

func (*DirectiveListContext) EXPR_LIST 

func (s *DirectiveListContext) EXPR_LIST(i int) antlr.TerminalNode

func (*DirectiveListContext) EXPR_SYMBOL 

func (s *DirectiveListContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*DirectiveListContext) GetKey 

func (s *DirectiveListContext) GetKey() antlr.Token

func (*DirectiveListContext) GetParser 

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

func (*DirectiveListContext) GetRuleContext 

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

func (*DirectiveListContext) GetValue 

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

func (*DirectiveListContext) IsDirectiveListContext 

func (*DirectiveListContext) IsDirectiveListContext()

func (*DirectiveListContext) START_DIRECTIVE_TAG 

func (s *DirectiveListContext) START_DIRECTIVE_TAG(i int) antlr.TerminalNode

func (*DirectiveListContext) SetKey 

func (s *DirectiveListContext) SetKey(v antlr.Token)

func (*DirectiveListContext) SetValue 

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

func (*DirectiveListContext) TagExpr 

func (s *DirectiveListContext) TagExpr() ITagExprContext

func (*DirectiveListContext) ToStringTree 

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

type DirectiveListElseElementsContext 

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

func NewDirectiveListElseElementsContext 

func NewDirectiveListElseElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveListElseElementsContext

func NewEmptyDirectiveListElseElementsContext 

func NewEmptyDirectiveListElseElementsContext() *DirectiveListElseElementsContext

func (*DirectiveListElseElementsContext) Accept 

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

func (*DirectiveListElseElementsContext) Elements 

func (s *DirectiveListElseElementsContext) Elements() IElementsContext

func (*DirectiveListElseElementsContext) GetParser 

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

func (*DirectiveListElseElementsContext) GetRuleContext 

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

func (*DirectiveListElseElementsContext) IsDirectiveListElseElementsContext 

func (*DirectiveListElseElementsContext) IsDirectiveListElseElementsContext()

func (*DirectiveListElseElementsContext) ToStringTree 

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

type DirectiveMacroContext 

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

func NewDirectiveMacroContext 

func NewDirectiveMacroContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveMacroContext

func NewEmptyDirectiveMacroContext 

func NewEmptyDirectiveMacroContext() *DirectiveMacroContext

func (*DirectiveMacroContext) Accept 

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

func (*DirectiveMacroContext) AllEXPR_EXIT_GT 

func (s *DirectiveMacroContext) AllEXPR_EXIT_GT() []antlr.TerminalNode

func (*DirectiveMacroContext) AllEXPR_MACRO 

func (s *DirectiveMacroContext) AllEXPR_MACRO() []antlr.TerminalNode

func (*DirectiveMacroContext) AllEXPR_SYMBOL 

func (s *DirectiveMacroContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*DirectiveMacroContext) END_DIRECTIVE_TAG 

func (s *DirectiveMacroContext) END_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveMacroContext) EXPR_EXIT_GT 

func (s *DirectiveMacroContext) EXPR_EXIT_GT(i int) antlr.TerminalNode

func (*DirectiveMacroContext) EXPR_MACRO 

func (s *DirectiveMacroContext) EXPR_MACRO(i int) antlr.TerminalNode

func (*DirectiveMacroContext) EXPR_SYMBOL 

func (s *DirectiveMacroContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*DirectiveMacroContext) Elements 

func (s *DirectiveMacroContext) Elements() IElementsContext

func (*DirectiveMacroContext) GetParser 

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

func (*DirectiveMacroContext) GetRuleContext 

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

func (*DirectiveMacroContext) IsDirectiveMacroContext 

func (*DirectiveMacroContext) IsDirectiveMacroContext()

func (*DirectiveMacroContext) START_DIRECTIVE_TAG 

func (s *DirectiveMacroContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveMacroContext) ToStringTree 

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

type DirectiveNestedContext 

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

func NewDirectiveNestedContext 

func NewDirectiveNestedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveNestedContext

func NewEmptyDirectiveNestedContext 

func NewEmptyDirectiveNestedContext() *DirectiveNestedContext

func (*DirectiveNestedContext) Accept 

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

func (*DirectiveNestedContext) AllEXPR_COMMA 

func (s *DirectiveNestedContext) AllEXPR_COMMA() []antlr.TerminalNode

func (*DirectiveNestedContext) AllExpr 

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

func (*DirectiveNestedContext) EXPR_COMMA 

func (s *DirectiveNestedContext) EXPR_COMMA(i int) antlr.TerminalNode

func (*DirectiveNestedContext) EXPR_EXIT_GT 

func (s *DirectiveNestedContext) EXPR_EXIT_GT() antlr.TerminalNode

func (*DirectiveNestedContext) EXPR_NESTED 

func (s *DirectiveNestedContext) EXPR_NESTED() antlr.TerminalNode

func (*DirectiveNestedContext) Expr 

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

func (*DirectiveNestedContext) GetParser 

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

func (*DirectiveNestedContext) GetRuleContext 

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

func (*DirectiveNestedContext) IsDirectiveNestedContext 

func (*DirectiveNestedContext) IsDirectiveNestedContext()

func (*DirectiveNestedContext) START_DIRECTIVE_TAG 

func (s *DirectiveNestedContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveNestedContext) ToStringTree 

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

type DirectiveReturnContext 

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

func NewDirectiveReturnContext 

func NewDirectiveReturnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveReturnContext

func NewEmptyDirectiveReturnContext 

func NewEmptyDirectiveReturnContext() *DirectiveReturnContext

func (*DirectiveReturnContext) Accept 

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

func (*DirectiveReturnContext) EXPR_EXIT_GT 

func (s *DirectiveReturnContext) EXPR_EXIT_GT() antlr.TerminalNode

func (*DirectiveReturnContext) EXPR_RETURN 

func (s *DirectiveReturnContext) EXPR_RETURN() antlr.TerminalNode

func (*DirectiveReturnContext) GetParser 

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

func (*DirectiveReturnContext) GetRuleContext 

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

func (*DirectiveReturnContext) IsDirectiveReturnContext 

func (*DirectiveReturnContext) IsDirectiveReturnContext()

func (*DirectiveReturnContext) START_DIRECTIVE_TAG 

func (s *DirectiveReturnContext) START_DIRECTIVE_TAG() antlr.TerminalNode

func (*DirectiveReturnContext) ToStringTree 

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

type DirectiveUserContext 

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

func NewDirectiveUserContext 

func NewDirectiveUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveUserContext

func NewEmptyDirectiveUserContext 

func NewEmptyDirectiveUserContext() *DirectiveUserContext

func (*DirectiveUserContext) Accept 

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

func (*DirectiveUserContext) AllDirectiveUserId 

func (s *DirectiveUserContext) AllDirectiveUserId() []IDirectiveUserIdContext

func (*DirectiveUserContext) AllEXPR_EXIT_GT 

func (s *DirectiveUserContext) AllEXPR_EXIT_GT() []antlr.TerminalNode

func (*DirectiveUserContext) DirectiveUserId 

func (s *DirectiveUserContext) DirectiveUserId(i int) IDirectiveUserIdContext

func (*DirectiveUserContext) DirectiveUserLoopParams 

func (s *DirectiveUserContext) DirectiveUserLoopParams() IDirectiveUserLoopParamsContext

func (*DirectiveUserContext) DirectiveUserParams 

func (s *DirectiveUserContext) DirectiveUserParams() IDirectiveUserParamsContext

func (*DirectiveUserContext) END_USER_DIR_TAG 

func (s *DirectiveUserContext) END_USER_DIR_TAG() antlr.TerminalNode

func (*DirectiveUserContext) EXPR_EXIT_DIV_GT 

func (s *DirectiveUserContext) EXPR_EXIT_DIV_GT() antlr.TerminalNode

func (*DirectiveUserContext) EXPR_EXIT_GT 

func (s *DirectiveUserContext) EXPR_EXIT_GT(i int) antlr.TerminalNode

func (*DirectiveUserContext) Elements 

func (s *DirectiveUserContext) Elements() IElementsContext

func (*DirectiveUserContext) GetParser 

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

func (*DirectiveUserContext) GetRuleContext 

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

func (*DirectiveUserContext) IsDirectiveUserContext 

func (*DirectiveUserContext) IsDirectiveUserContext()

func (*DirectiveUserContext) START_USER_DIR_TAG 

func (s *DirectiveUserContext) START_USER_DIR_TAG() antlr.TerminalNode

func (*DirectiveUserContext) ToStringTree 

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

type DirectiveUserIdContext 

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

func NewDirectiveUserIdContext 

func NewDirectiveUserIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveUserIdContext

func NewEmptyDirectiveUserIdContext 

func NewEmptyDirectiveUserIdContext() *DirectiveUserIdContext

func (*DirectiveUserIdContext) Accept 

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

func (*DirectiveUserIdContext) AllEXPR_DOT 

func (s *DirectiveUserIdContext) AllEXPR_DOT() []antlr.TerminalNode

func (*DirectiveUserIdContext) AllEXPR_SYMBOL 

func (s *DirectiveUserIdContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*DirectiveUserIdContext) EXPR_DOT 

func (s *DirectiveUserIdContext) EXPR_DOT(i int) antlr.TerminalNode

func (*DirectiveUserIdContext) EXPR_SYMBOL 

func (s *DirectiveUserIdContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*DirectiveUserIdContext) GetParser 

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

func (*DirectiveUserIdContext) GetRuleContext 

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

func (*DirectiveUserIdContext) IsDirectiveUserIdContext 

func (*DirectiveUserIdContext) IsDirectiveUserIdContext()

func (*DirectiveUserIdContext) ToStringTree 

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

type DirectiveUserLoopParamsContext 

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

func NewDirectiveUserLoopParamsContext 

func NewDirectiveUserLoopParamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveUserLoopParamsContext

func NewEmptyDirectiveUserLoopParamsContext 

func NewEmptyDirectiveUserLoopParamsContext() *DirectiveUserLoopParamsContext

func (*DirectiveUserLoopParamsContext) Accept 

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

func (*DirectiveUserLoopParamsContext) AllEXPR_COMMA 

func (s *DirectiveUserLoopParamsContext) AllEXPR_COMMA() []antlr.TerminalNode

func (*DirectiveUserLoopParamsContext) AllEXPR_SYMBOL 

func (s *DirectiveUserLoopParamsContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*DirectiveUserLoopParamsContext) EXPR_COMMA 

func (s *DirectiveUserLoopParamsContext) EXPR_COMMA(i int) antlr.TerminalNode

func (*DirectiveUserLoopParamsContext) EXPR_SEMICOLON 

func (s *DirectiveUserLoopParamsContext) EXPR_SEMICOLON() antlr.TerminalNode

func (*DirectiveUserLoopParamsContext) EXPR_SYMBOL 

func (s *DirectiveUserLoopParamsContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*DirectiveUserLoopParamsContext) GetParser 

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

func (*DirectiveUserLoopParamsContext) GetRuleContext 

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

func (*DirectiveUserLoopParamsContext) IsDirectiveUserLoopParamsContext 

func (*DirectiveUserLoopParamsContext) IsDirectiveUserLoopParamsContext()

func (*DirectiveUserLoopParamsContext) ToStringTree 

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

type DirectiveUserParamsContext 

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

func NewDirectiveUserParamsContext 

func NewDirectiveUserParamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectiveUserParamsContext

func NewEmptyDirectiveUserParamsContext 

func NewEmptyDirectiveUserParamsContext() *DirectiveUserParamsContext

func (*DirectiveUserParamsContext) Accept 

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

func (*DirectiveUserParamsContext) AllEXPR_COMMA 

func (s *DirectiveUserParamsContext) AllEXPR_COMMA() []antlr.TerminalNode

func (*DirectiveUserParamsContext) AllEXPR_EQ 

func (s *DirectiveUserParamsContext) AllEXPR_EQ() []antlr.TerminalNode

func (*DirectiveUserParamsContext) AllEXPR_SYMBOL 

func (s *DirectiveUserParamsContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*DirectiveUserParamsContext) AllExpr 

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

func (*DirectiveUserParamsContext) EXPR_COMMA 

func (s *DirectiveUserParamsContext) EXPR_COMMA(i int) antlr.TerminalNode

func (*DirectiveUserParamsContext) EXPR_EQ 

func (s *DirectiveUserParamsContext) EXPR_EQ(i int) antlr.TerminalNode

func (*DirectiveUserParamsContext) EXPR_SYMBOL 

func (s *DirectiveUserParamsContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*DirectiveUserParamsContext) Expr 

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

func (*DirectiveUserParamsContext) GetParser 

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

func (*DirectiveUserParamsContext) GetRuleContext 

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

func (*DirectiveUserParamsContext) IsDirectiveUserParamsContext 

func (*DirectiveUserParamsContext) IsDirectiveUserParamsContext()

func (*DirectiveUserParamsContext) ToStringTree 

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

type DoubleQuoteContext 

type DoubleQuoteContext struct {
	*StringContext
}

func NewDoubleQuoteContext 

func NewDoubleQuoteContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoubleQuoteContext

func (*DoubleQuoteContext) Accept 

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

func (*DoubleQuoteContext) Double_quote_string 

func (s *DoubleQuoteContext) Double_quote_string() IDouble_quote_stringContext

func (*DoubleQuoteContext) GetRuleContext 

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

type Double_quote_stringContext 

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

func NewDouble_quote_stringContext 

func NewDouble_quote_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Double_quote_stringContext

func NewEmptyDouble_quote_stringContext 

func NewEmptyDouble_quote_stringContext() *Double_quote_stringContext

func (*Double_quote_stringContext) Accept 

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

func (*Double_quote_stringContext) AllDQS_CONTENT 

func (s *Double_quote_stringContext) AllDQS_CONTENT() []antlr.TerminalNode

func (*Double_quote_stringContext) AllDQS_ENTER_EXPR 

func (s *Double_quote_stringContext) AllDQS_ENTER_EXPR() []antlr.TerminalNode

func (*Double_quote_stringContext) AllDQS_ESCAPE 

func (s *Double_quote_stringContext) AllDQS_ESCAPE() []antlr.TerminalNode

func (*Double_quote_stringContext) AllEXPR_EXIT_R_BRACE 

func (s *Double_quote_stringContext) AllEXPR_EXIT_R_BRACE() []antlr.TerminalNode

func (*Double_quote_stringContext) AllExpr 

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

func (*Double_quote_stringContext) DQS_CONTENT 

func (s *Double_quote_stringContext) DQS_CONTENT(i int) antlr.TerminalNode

func (*Double_quote_stringContext) DQS_ENTER_EXPR 

func (s *Double_quote_stringContext) DQS_ENTER_EXPR(i int) antlr.TerminalNode

func (*Double_quote_stringContext) DQS_ESCAPE 

func (s *Double_quote_stringContext) DQS_ESCAPE(i int) antlr.TerminalNode

func (*Double_quote_stringContext) DQS_EXIT 

func (s *Double_quote_stringContext) DQS_EXIT() antlr.TerminalNode

func (*Double_quote_stringContext) EXPR_DOUBLE_STR_START 

func (s *Double_quote_stringContext) EXPR_DOUBLE_STR_START() antlr.TerminalNode

func (*Double_quote_stringContext) EXPR_EXIT_R_BRACE 

func (s *Double_quote_stringContext) EXPR_EXIT_R_BRACE(i int) antlr.TerminalNode

func (*Double_quote_stringContext) Expr 

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

func (*Double_quote_stringContext) GetParser 

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

func (*Double_quote_stringContext) GetRuleContext 

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

func (*Double_quote_stringContext) IsDouble_quote_stringContext 

func (*Double_quote_stringContext) IsDouble_quote_stringContext()

func (*Double_quote_stringContext) ToStringTree 

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

type ElementContext 

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

func NewElementContext 

func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext

func NewEmptyElementContext 

func NewEmptyElementContext() *ElementContext

func (*ElementContext) CopyFrom 

func (s *ElementContext) CopyFrom(ctx *ElementContext)

func (*ElementContext) GetParser 

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

func (*ElementContext) GetRuleContext 

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

func (*ElementContext) IsElementContext 

func (*ElementContext) IsElementContext()

func (*ElementContext) ToStringTree 

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

type ElementsContext 

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

func NewElementsContext 

func NewElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementsContext

func NewEmptyElementsContext 

func NewEmptyElementsContext() *ElementsContext

func (*ElementsContext) Accept 

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

func (*ElementsContext) AllElement 

func (s *ElementsContext) AllElement() []IElementContext

func (*ElementsContext) Element 

func (s *ElementsContext) Element(i int) IElementContext

func (*ElementsContext) GetParser 

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

func (*ElementsContext) GetRuleContext 

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

func (*ElementsContext) IsElementsContext 

func (*ElementsContext) IsElementsContext()

func (*ElementsContext) ToStringTree 

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

type ExprAddSubContext 

type ExprAddSubContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewExprAddSubContext 

func NewExprAddSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAddSubContext

func (*ExprAddSubContext) Accept 

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

func (*ExprAddSubContext) AllExpr 

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

func (*ExprAddSubContext) EXPR_ADD 

func (s *ExprAddSubContext) EXPR_ADD() antlr.TerminalNode

func (*ExprAddSubContext) EXPR_SUB 

func (s *ExprAddSubContext) EXPR_SUB() antlr.TerminalNode

func (*ExprAddSubContext) Expr 

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

func (*ExprAddSubContext) GetOp 

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

func (*ExprAddSubContext) GetRuleContext 

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

func (*ExprAddSubContext) SetOp 

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

type ExprBoolAndContext 

type ExprBoolAndContext struct {
	*ExprContext
}

func NewExprBoolAndContext 

func NewExprBoolAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBoolAndContext

func (*ExprBoolAndContext) Accept 

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

func (*ExprBoolAndContext) AllExpr 

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

func (*ExprBoolAndContext) EXPR_LOGICAL_AND 

func (s *ExprBoolAndContext) EXPR_LOGICAL_AND() antlr.TerminalNode

func (*ExprBoolAndContext) Expr 

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

func (*ExprBoolAndContext) GetRuleContext 

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

type ExprBoolEqContext 

type ExprBoolEqContext struct {
	*ExprContext
}

func NewExprBoolEqContext 

func NewExprBoolEqContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBoolEqContext

func (*ExprBoolEqContext) Accept 

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

func (*ExprBoolEqContext) AllExpr 

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

func (*ExprBoolEqContext) EXPR_COMPARE_EQ 

func (s *ExprBoolEqContext) EXPR_COMPARE_EQ() antlr.TerminalNode

func (*ExprBoolEqContext) EXPR_COMPARE_NEQ 

func (s *ExprBoolEqContext) EXPR_COMPARE_NEQ() antlr.TerminalNode

func (*ExprBoolEqContext) EXPR_EQ 

func (s *ExprBoolEqContext) EXPR_EQ() antlr.TerminalNode

func (*ExprBoolEqContext) Expr 

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

func (*ExprBoolEqContext) GetRuleContext 

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

type ExprBoolOrContext 

type ExprBoolOrContext struct {
	*ExprContext
}

func NewExprBoolOrContext 

func NewExprBoolOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBoolOrContext

func (*ExprBoolOrContext) Accept 

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

func (*ExprBoolOrContext) AllExpr 

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

func (*ExprBoolOrContext) EXPR_LOGICAL_OR 

func (s *ExprBoolOrContext) EXPR_LOGICAL_OR() antlr.TerminalNode

func (*ExprBoolOrContext) Expr 

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

func (*ExprBoolOrContext) GetRuleContext 

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

type ExprBoolRelationalContext 

type ExprBoolRelationalContext struct {
	*ExprContext
}

func NewExprBoolRelationalContext 

func NewExprBoolRelationalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBoolRelationalContext

func (*ExprBoolRelationalContext) Accept 

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

func (*ExprBoolRelationalContext) AllExpr 

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

func (*ExprBoolRelationalContext) BooleanRelationalOperator 

func (s *ExprBoolRelationalContext) BooleanRelationalOperator() IBooleanRelationalOperatorContext

func (*ExprBoolRelationalContext) Expr 

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

func (*ExprBoolRelationalContext) GetRuleContext 

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

type ExprBuiltInContext 

type ExprBuiltInContext struct {
	*ExprContext
}

func NewExprBuiltInContext 

func NewExprBuiltInContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBuiltInContext

func (*ExprBuiltInContext) Accept 

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

func (*ExprBuiltInContext) EXPR_L_PAREN 

func (s *ExprBuiltInContext) EXPR_L_PAREN() antlr.TerminalNode

func (*ExprBuiltInContext) EXPR_QUESTION 

func (s *ExprBuiltInContext) EXPR_QUESTION() antlr.TerminalNode

func (*ExprBuiltInContext) EXPR_R_PAREN 

func (s *ExprBuiltInContext) EXPR_R_PAREN() antlr.TerminalNode

func (*ExprBuiltInContext) EXPR_SYMBOL 

func (s *ExprBuiltInContext) EXPR_SYMBOL() antlr.TerminalNode

func (*ExprBuiltInContext) Expr 

func (s *ExprBuiltInContext) Expr() IExprContext

func (*ExprBuiltInContext) FunctionParams 

func (s *ExprBuiltInContext) FunctionParams() IFunctionParamsContext

func (*ExprBuiltInContext) GetRuleContext 

func (s *ExprBuiltInContext) 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 ExprDefaultContext 

type ExprDefaultContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewExprDefaultContext 

func NewExprDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprDefaultContext

func (*ExprDefaultContext) Accept 

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

func (*ExprDefaultContext) AllExpr 

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

func (*ExprDefaultContext) EXPR_BANG 

func (s *ExprDefaultContext) EXPR_BANG() antlr.TerminalNode

func (*ExprDefaultContext) Expr 

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

func (*ExprDefaultContext) GetLeft 

func (s *ExprDefaultContext) GetLeft() IExprContext

func (*ExprDefaultContext) GetRight 

func (s *ExprDefaultContext) GetRight() IExprContext

func (*ExprDefaultContext) GetRuleContext 

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

func (*ExprDefaultContext) SetLeft 

func (s *ExprDefaultContext) SetLeft(v IExprContext)

func (*ExprDefaultContext) SetRight 

func (s *ExprDefaultContext) SetRight(v IExprContext)

type ExprDotAccessContext 

type ExprDotAccessContext struct {
	*ExprContext
}

func NewExprDotAccessContext 

func NewExprDotAccessContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprDotAccessContext

func (*ExprDotAccessContext) Accept 

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

func (*ExprDotAccessContext) AllEXPR_DOT 

func (s *ExprDotAccessContext) AllEXPR_DOT() []antlr.TerminalNode

func (*ExprDotAccessContext) AllEXPR_SYMBOL 

func (s *ExprDotAccessContext) AllEXPR_SYMBOL() []antlr.TerminalNode

func (*ExprDotAccessContext) EXPR_DOT 

func (s *ExprDotAccessContext) EXPR_DOT(i int) antlr.TerminalNode

func (*ExprDotAccessContext) EXPR_SYMBOL 

func (s *ExprDotAccessContext) EXPR_SYMBOL(i int) antlr.TerminalNode

func (*ExprDotAccessContext) Expr 

func (s *ExprDotAccessContext) Expr() IExprContext

func (*ExprDotAccessContext) GetRuleContext 

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

type ExprFunctionCallContext 

type ExprFunctionCallContext struct {
	*ExprContext
}

func NewExprFunctionCallContext 

func NewExprFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprFunctionCallContext

func (*ExprFunctionCallContext) Accept 

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

func (*ExprFunctionCallContext) EXPR_L_PAREN 

func (s *ExprFunctionCallContext) EXPR_L_PAREN() antlr.TerminalNode

func (*ExprFunctionCallContext) EXPR_R_PAREN 

func (s *ExprFunctionCallContext) EXPR_R_PAREN() antlr.TerminalNode

func (*ExprFunctionCallContext) Expr 

func (s *ExprFunctionCallContext) Expr() IExprContext

func (*ExprFunctionCallContext) FunctionParams 

func (s *ExprFunctionCallContext) FunctionParams() IFunctionParamsContext

func (*ExprFunctionCallContext) GetRuleContext 

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

type ExprMissingTestContext 

type ExprMissingTestContext struct {
	*ExprContext
}

func NewExprMissingTestContext 

func NewExprMissingTestContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprMissingTestContext

func (*ExprMissingTestContext) Accept 

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

func (*ExprMissingTestContext) EXPR_DBL_QUESTION 

func (s *ExprMissingTestContext) EXPR_DBL_QUESTION() antlr.TerminalNode

func (*ExprMissingTestContext) Expr 

func (s *ExprMissingTestContext) Expr() IExprContext

func (*ExprMissingTestContext) GetRuleContext 

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

type ExprMulDivModContext 

type ExprMulDivModContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewExprMulDivModContext 

func NewExprMulDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprMulDivModContext

func (*ExprMulDivModContext) Accept 

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

func (*ExprMulDivModContext) AllExpr 

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

func (*ExprMulDivModContext) EXPR_DIV 

func (s *ExprMulDivModContext) EXPR_DIV() antlr.TerminalNode

func (*ExprMulDivModContext) EXPR_MOD 

func (s *ExprMulDivModContext) EXPR_MOD() antlr.TerminalNode

func (*ExprMulDivModContext) EXPR_MUL 

func (s *ExprMulDivModContext) EXPR_MUL() antlr.TerminalNode

func (*ExprMulDivModContext) Expr 

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

func (*ExprMulDivModContext) GetOp 

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

func (*ExprMulDivModContext) GetRuleContext 

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

func (*ExprMulDivModContext) SetOp 

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

type ExprRoundParenthesesContext 

type ExprRoundParenthesesContext struct {
	*ExprContext
}

func NewExprRoundParenthesesContext 

func NewExprRoundParenthesesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprRoundParenthesesContext

func (*ExprRoundParenthesesContext) Accept 

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

func (*ExprRoundParenthesesContext) EXPR_L_PAREN 

func (s *ExprRoundParenthesesContext) EXPR_L_PAREN() antlr.TerminalNode

func (*ExprRoundParenthesesContext) EXPR_R_PAREN 

func (s *ExprRoundParenthesesContext) EXPR_R_PAREN() antlr.TerminalNode

func (*ExprRoundParenthesesContext) Expr 

func (s *ExprRoundParenthesesContext) Expr() IExprContext

func (*ExprRoundParenthesesContext) GetRuleContext 

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

type ExprSquareParenthesesContext 

type ExprSquareParenthesesContext struct {
	*ExprContext
}

func NewExprSquareParenthesesContext 

func NewExprSquareParenthesesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprSquareParenthesesContext

func (*ExprSquareParenthesesContext) Accept 

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

func (*ExprSquareParenthesesContext) AllExpr 

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

func (*ExprSquareParenthesesContext) EXPR_L_SQ_PAREN 

func (s *ExprSquareParenthesesContext) EXPR_L_SQ_PAREN() antlr.TerminalNode

func (*ExprSquareParenthesesContext) EXPR_R_SQ_PAREN 

func (s *ExprSquareParenthesesContext) EXPR_R_SQ_PAREN() antlr.TerminalNode

func (*ExprSquareParenthesesContext) Expr 

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

func (*ExprSquareParenthesesContext) GetRuleContext 

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

type ExprUnaryOpContext 

type ExprUnaryOpContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewExprUnaryOpContext 

func NewExprUnaryOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUnaryOpContext

func (*ExprUnaryOpContext) Accept 

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

func (*ExprUnaryOpContext) EXPR_BANG 

func (s *ExprUnaryOpContext) EXPR_BANG() antlr.TerminalNode

func (*ExprUnaryOpContext) EXPR_SUB 

func (s *ExprUnaryOpContext) EXPR_SUB() antlr.TerminalNode

func (*ExprUnaryOpContext) Expr 

func (s *ExprUnaryOpContext) Expr() IExprContext

func (*ExprUnaryOpContext) GetOp 

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

func (*ExprUnaryOpContext) GetRuleContext 

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

func (*ExprUnaryOpContext) SetOp 

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

type FreemarkerLexer 

type FreemarkerLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewFreemarkerLexer 

func NewFreemarkerLexer(input antlr.CharStream) *FreemarkerLexer

NewFreemarkerLexer produces a new lexer instance for the optional input antlr.CharStream.

type FreemarkerParser 

type FreemarkerParser struct {
	*antlr.BaseParser
}

func NewFreemarkerParser 

func NewFreemarkerParser(input antlr.TokenStream) *FreemarkerParser

NewFreemarkerParser produces a new parser instance for the optional input antlr.TokenStream.

func (*FreemarkerParser) BooleanRelationalOperator 

func (p *FreemarkerParser) BooleanRelationalOperator() (localctx IBooleanRelationalOperatorContext)

func (*FreemarkerParser) Directive 

func (p *FreemarkerParser) Directive() (localctx IDirectiveContext)

func (*FreemarkerParser) DirectiveAssign 

func (p *FreemarkerParser) DirectiveAssign() (localctx IDirectiveAssignContext)

func (*FreemarkerParser) DirectiveIf 

func (p *FreemarkerParser) DirectiveIf() (localctx IDirectiveIfContext)

func (*FreemarkerParser) DirectiveIfElseElements 

func (p *FreemarkerParser) DirectiveIfElseElements() (localctx IDirectiveIfElseElementsContext)

func (*FreemarkerParser) DirectiveIfElseIfElements 

func (p *FreemarkerParser) DirectiveIfElseIfElements() (localctx IDirectiveIfElseIfElementsContext)

func (*FreemarkerParser) DirectiveIfTrueElements 

func (p *FreemarkerParser) DirectiveIfTrueElements() (localctx IDirectiveIfTrueElementsContext)

func (*FreemarkerParser) DirectiveImport 

func (p *FreemarkerParser) DirectiveImport() (localctx IDirectiveImportContext)

func (*FreemarkerParser) DirectiveInclude 

func (p *FreemarkerParser) DirectiveInclude() (localctx IDirectiveIncludeContext)

func (*FreemarkerParser) DirectiveList 

func (p *FreemarkerParser) DirectiveList() (localctx IDirectiveListContext)

func (*FreemarkerParser) DirectiveListBodyElements 

func (p *FreemarkerParser) DirectiveListBodyElements() (localctx IDirectiveListBodyElementsContext)

func (*FreemarkerParser) DirectiveListElseElements 

func (p *FreemarkerParser) DirectiveListElseElements() (localctx IDirectiveListElseElementsContext)

func (*FreemarkerParser) DirectiveMacro 

func (p *FreemarkerParser) DirectiveMacro() (localctx IDirectiveMacroContext)

func (*FreemarkerParser) DirectiveNested 

func (p *FreemarkerParser) DirectiveNested() (localctx IDirectiveNestedContext)

func (*FreemarkerParser) DirectiveReturn 

func (p *FreemarkerParser) DirectiveReturn() (localctx IDirectiveReturnContext)

func (*FreemarkerParser) DirectiveUser 

func (p *FreemarkerParser) DirectiveUser() (localctx IDirectiveUserContext)

func (*FreemarkerParser) DirectiveUserId 

func (p *FreemarkerParser) DirectiveUserId() (localctx IDirectiveUserIdContext)

func (*FreemarkerParser) DirectiveUserLoopParams 

func (p *FreemarkerParser) DirectiveUserLoopParams() (localctx IDirectiveUserLoopParamsContext)

func (*FreemarkerParser) DirectiveUserParams 

func (p *FreemarkerParser) DirectiveUserParams() (localctx IDirectiveUserParamsContext)

func (*FreemarkerParser) Double_quote_string 

func (p *FreemarkerParser) Double_quote_string() (localctx IDouble_quote_stringContext)

func (*FreemarkerParser) Element 

func (p *FreemarkerParser) Element() (localctx IElementContext)

func (*FreemarkerParser) Elements 

func (p *FreemarkerParser) Elements() (localctx IElementsContext)

func (*FreemarkerParser) Expr 

func (p *FreemarkerParser) Expr() (localctx IExprContext)

func (*FreemarkerParser) Expr_Sempred 

func (p *FreemarkerParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*FreemarkerParser) FunctionParams 

func (p *FreemarkerParser) FunctionParams() (localctx IFunctionParamsContext)

func (*FreemarkerParser) InlineExpr 

func (p *FreemarkerParser) InlineExpr() (localctx IInlineExprContext)

func (*FreemarkerParser) RawText 

func (p *FreemarkerParser) RawText() (localctx IRawTextContext)

func (*FreemarkerParser) Sempred 

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

func (*FreemarkerParser) Single_quote_string 

func (p *FreemarkerParser) Single_quote_string() (localctx ISingle_quote_stringContext)

func (*FreemarkerParser) String_ 

func (p *FreemarkerParser) String_() (localctx IStringContext)

func (*FreemarkerParser) Struct_ 

func (p *FreemarkerParser) Struct_() (localctx IStructContext)

func (*FreemarkerParser) Struct_pair 

func (p *FreemarkerParser) Struct_pair() (localctx IStruct_pairContext)

func (*FreemarkerParser) TagExpr 

func (p *FreemarkerParser) TagExpr() (localctx ITagExprContext)

func (*FreemarkerParser) TagExprElseIfs 

func (p *FreemarkerParser) TagExprElseIfs() (localctx ITagExprElseIfsContext)

func (*FreemarkerParser) Template 

func (p *FreemarkerParser) Template() (localctx ITemplateContext)

type FreemarkerParserVisitor 

type FreemarkerParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by FreemarkerParser#template.
	VisitTemplate(ctx *TemplateContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#elements.
	VisitElements(ctx *ElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#RawTextElement.
	VisitRawTextElement(ctx *RawTextElementContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#DirectiveElement.
	VisitDirectiveElement(ctx *DirectiveElementContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#InlineExprElement.
	VisitInlineExprElement(ctx *InlineExprElementContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#rawText.
	VisitRawText(ctx *RawTextContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directive.
	VisitDirective(ctx *DirectiveContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveIf.
	VisitDirectiveIf(ctx *DirectiveIfContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveIfTrueElements.
	VisitDirectiveIfTrueElements(ctx *DirectiveIfTrueElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveIfElseIfElements.
	VisitDirectiveIfElseIfElements(ctx *DirectiveIfElseIfElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveIfElseElements.
	VisitDirectiveIfElseElements(ctx *DirectiveIfElseElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#tagExprElseIfs.
	VisitTagExprElseIfs(ctx *TagExprElseIfsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveAssign.
	VisitDirectiveAssign(ctx *DirectiveAssignContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveList.
	VisitDirectiveList(ctx *DirectiveListContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveListBodyElements.
	VisitDirectiveListBodyElements(ctx *DirectiveListBodyElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveListElseElements.
	VisitDirectiveListElseElements(ctx *DirectiveListElseElementsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveInclude.
	VisitDirectiveInclude(ctx *DirectiveIncludeContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveImport.
	VisitDirectiveImport(ctx *DirectiveImportContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveMacro.
	VisitDirectiveMacro(ctx *DirectiveMacroContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveNested.
	VisitDirectiveNested(ctx *DirectiveNestedContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveReturn.
	VisitDirectiveReturn(ctx *DirectiveReturnContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveUser.
	VisitDirectiveUser(ctx *DirectiveUserContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveUserId.
	VisitDirectiveUserId(ctx *DirectiveUserIdContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveUserParams.
	VisitDirectiveUserParams(ctx *DirectiveUserParamsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#directiveUserLoopParams.
	VisitDirectiveUserLoopParams(ctx *DirectiveUserLoopParamsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#tagExpr.
	VisitTagExpr(ctx *TagExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#inlineExpr.
	VisitInlineExpr(ctx *InlineExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#SingleQuote.
	VisitSingleQuote(ctx *SingleQuoteContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#DoubleQuote.
	VisitDoubleQuote(ctx *DoubleQuoteContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprUnaryOp.
	VisitExprUnaryOp(ctx *ExprUnaryOpContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprMulDivMod.
	VisitExprMulDivMod(ctx *ExprMulDivModContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#BoolExpr.
	VisitBoolExpr(ctx *BoolExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#StringExpr.
	VisitStringExpr(ctx *StringExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprBoolRelational.
	VisitExprBoolRelational(ctx *ExprBoolRelationalContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprRoundParentheses.
	VisitExprRoundParentheses(ctx *ExprRoundParenthesesContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprBoolAnd.
	VisitExprBoolAnd(ctx *ExprBoolAndContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#SymbolExpr.
	VisitSymbolExpr(ctx *SymbolExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprBuiltIn.
	VisitExprBuiltIn(ctx *ExprBuiltInContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#StructExpr.
	VisitStructExpr(ctx *StructExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprMissingTest.
	VisitExprMissingTest(ctx *ExprMissingTestContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprAddSub.
	VisitExprAddSub(ctx *ExprAddSubContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprDotAccess.
	VisitExprDotAccess(ctx *ExprDotAccessContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprBoolEq.
	VisitExprBoolEq(ctx *ExprBoolEqContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprFunctionCall.
	VisitExprFunctionCall(ctx *ExprFunctionCallContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#NumberExpr.
	VisitNumberExpr(ctx *NumberExprContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprDefault.
	VisitExprDefault(ctx *ExprDefaultContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprSquareParentheses.
	VisitExprSquareParentheses(ctx *ExprSquareParenthesesContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#ExprBoolOr.
	VisitExprBoolOr(ctx *ExprBoolOrContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#functionParams.
	VisitFunctionParams(ctx *FunctionParamsContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#booleanRelationalOperator.
	VisitBooleanRelationalOperator(ctx *BooleanRelationalOperatorContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#struct.
	VisitStruct(ctx *StructContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#struct_pair.
	VisitStruct_pair(ctx *Struct_pairContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#single_quote_string.
	VisitSingle_quote_string(ctx *Single_quote_stringContext) interface{}

	// Visit a parse tree produced by FreemarkerParser#double_quote_string.
	VisitDouble_quote_string(ctx *Double_quote_stringContext) interface{}
}

A complete Visitor for a parse tree produced by FreemarkerParser.

type FunctionParamsContext 

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

func NewEmptyFunctionParamsContext 

func NewEmptyFunctionParamsContext() *FunctionParamsContext

func NewFunctionParamsContext 

func NewFunctionParamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionParamsContext

func (*FunctionParamsContext) Accept 

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

func (*FunctionParamsContext) AllEXPR_COMMA 

func (s *FunctionParamsContext) AllEXPR_COMMA() []antlr.TerminalNode

func (*FunctionParamsContext) AllExpr 

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

func (*FunctionParamsContext) EXPR_COMMA 

func (s *FunctionParamsContext) EXPR_COMMA(i int) antlr.TerminalNode

func (*FunctionParamsContext) Expr 

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

func (*FunctionParamsContext) GetParser 

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

func (*FunctionParamsContext) GetRuleContext 

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

func (*FunctionParamsContext) IsFunctionParamsContext 

func (*FunctionParamsContext) IsFunctionParamsContext()

func (*FunctionParamsContext) ToStringTree 

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

type IBooleanRelationalOperatorContext 

type IBooleanRelationalOperatorContext interface {
	antlr.ParserRuleContext

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

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

IBooleanRelationalOperatorContext is an interface to support dynamic dispatch.

type IDirectiveAssignContext 

type IDirectiveAssignContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveAssignContext is an interface to support dynamic dispatch.

type IDirectiveContext 

type IDirectiveContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveContext is an interface to support dynamic dispatch.

type IDirectiveIfContext 

type IDirectiveIfContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveIfContext is an interface to support dynamic dispatch.

type IDirectiveIfElseElementsContext 

type IDirectiveIfElseElementsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveIfElseElementsContext is an interface to support dynamic dispatch.

type IDirectiveIfElseIfElementsContext 

type IDirectiveIfElseIfElementsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveIfElseIfElementsContext is an interface to support dynamic dispatch.

type IDirectiveIfTrueElementsContext 

type IDirectiveIfTrueElementsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveIfTrueElementsContext is an interface to support dynamic dispatch.

type IDirectiveImportContext 

type IDirectiveImportContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveImportContext is an interface to support dynamic dispatch.

type IDirectiveIncludeContext 

type IDirectiveIncludeContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveIncludeContext is an interface to support dynamic dispatch.

type IDirectiveListBodyElementsContext 

type IDirectiveListBodyElementsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveListBodyElementsContext is an interface to support dynamic dispatch.

type IDirectiveListContext 

type IDirectiveListContext interface {
	antlr.ParserRuleContext

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

	// GetValue returns the value token.
	GetValue() antlr.Token

	// GetKey returns the key token.
	GetKey() antlr.Token

	// SetValue sets the value token.
	SetValue(antlr.Token)

	// SetKey sets the key token.
	SetKey(antlr.Token)

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

IDirectiveListContext is an interface to support dynamic dispatch.

type IDirectiveListElseElementsContext 

type IDirectiveListElseElementsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveListElseElementsContext is an interface to support dynamic dispatch.

type IDirectiveMacroContext 

type IDirectiveMacroContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveMacroContext is an interface to support dynamic dispatch.

type IDirectiveNestedContext 

type IDirectiveNestedContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveNestedContext is an interface to support dynamic dispatch.

type IDirectiveReturnContext 

type IDirectiveReturnContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveReturnContext is an interface to support dynamic dispatch.

type IDirectiveUserContext 

type IDirectiveUserContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveUserContext is an interface to support dynamic dispatch.

type IDirectiveUserIdContext 

type IDirectiveUserIdContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveUserIdContext is an interface to support dynamic dispatch.

type IDirectiveUserLoopParamsContext 

type IDirectiveUserLoopParamsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveUserLoopParamsContext is an interface to support dynamic dispatch.

type IDirectiveUserParamsContext 

type IDirectiveUserParamsContext interface {
	antlr.ParserRuleContext

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

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

IDirectiveUserParamsContext is an interface to support dynamic dispatch.

type IDouble_quote_stringContext 

type IDouble_quote_stringContext interface {
	antlr.ParserRuleContext

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

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

IDouble_quote_stringContext is an interface to support dynamic dispatch.

type IElementContext 

type IElementContext interface {
	antlr.ParserRuleContext

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

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

IElementContext is an interface to support dynamic dispatch.

type IElementsContext 

type IElementsContext interface {
	antlr.ParserRuleContext

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

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

IElementsContext 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 IFunctionParamsContext 

type IFunctionParamsContext interface {
	antlr.ParserRuleContext

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

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

IFunctionParamsContext is an interface to support dynamic dispatch.

type IInlineExprContext 

type IInlineExprContext interface {
	antlr.ParserRuleContext

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

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

IInlineExprContext is an interface to support dynamic dispatch.

type IRawTextContext 

type IRawTextContext interface {
	antlr.ParserRuleContext

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

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

IRawTextContext is an interface to support dynamic dispatch.

type ISingle_quote_stringContext 

type ISingle_quote_stringContext interface {
	antlr.ParserRuleContext

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

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

ISingle_quote_stringContext is an interface to support dynamic dispatch.

type IStringContext 

type IStringContext interface {
	antlr.ParserRuleContext

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

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

IStringContext is an interface to support dynamic dispatch.

type IStructContext 

type IStructContext interface {
	antlr.ParserRuleContext

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

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

IStructContext is an interface to support dynamic dispatch.

type IStruct_pairContext 

type IStruct_pairContext interface {
	antlr.ParserRuleContext

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

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

IStruct_pairContext is an interface to support dynamic dispatch.

type ITagExprContext 

type ITagExprContext interface {
	antlr.ParserRuleContext

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

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

ITagExprContext is an interface to support dynamic dispatch.

type ITagExprElseIfsContext 

type ITagExprElseIfsContext interface {
	antlr.ParserRuleContext

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

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

ITagExprElseIfsContext is an interface to support dynamic dispatch.

type ITemplateContext 

type ITemplateContext interface {
	antlr.ParserRuleContext

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

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

ITemplateContext is an interface to support dynamic dispatch.

type InlineExprContext 

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

func NewEmptyInlineExprContext 

func NewEmptyInlineExprContext() *InlineExprContext

func NewInlineExprContext 

func NewInlineExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InlineExprContext

func (*InlineExprContext) Accept 

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

func (*InlineExprContext) Expr 

func (s *InlineExprContext) Expr() IExprContext

func (*InlineExprContext) GetParser 

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

func (*InlineExprContext) GetRuleContext 

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

func (*InlineExprContext) IsInlineExprContext 

func (*InlineExprContext) IsInlineExprContext()

func (*InlineExprContext) ToStringTree 

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

type InlineExprElementContext 

type InlineExprElementContext struct {
	*ElementContext
}

func NewInlineExprElementContext 

func NewInlineExprElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InlineExprElementContext

func (*InlineExprElementContext) Accept 

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

func (*InlineExprElementContext) EXPR_EXIT_R_BRACE 

func (s *InlineExprElementContext) EXPR_EXIT_R_BRACE() antlr.TerminalNode

func (*InlineExprElementContext) GetRuleContext 

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

func (*InlineExprElementContext) INLINE_EXPR_START 

func (s *InlineExprElementContext) INLINE_EXPR_START() antlr.TerminalNode

func (*InlineExprElementContext) InlineExpr 

func (s *InlineExprElementContext) InlineExpr() IInlineExprContext

type NumberExprContext 

type NumberExprContext struct {
	*ExprContext
}

func NewNumberExprContext 

func NewNumberExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NumberExprContext

func (*NumberExprContext) Accept 

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

func (*NumberExprContext) EXPR_NUM 

func (s *NumberExprContext) EXPR_NUM() antlr.TerminalNode

func (*NumberExprContext) GetRuleContext 

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

type RawTextContext 

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

func NewEmptyRawTextContext 

func NewEmptyRawTextContext() *RawTextContext

func NewRawTextContext 

func NewRawTextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RawTextContext

func (*RawTextContext) Accept 

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

func (*RawTextContext) AllCONTENT 

func (s *RawTextContext) AllCONTENT() []antlr.TerminalNode

func (*RawTextContext) CONTENT 

func (s *RawTextContext) CONTENT(i int) antlr.TerminalNode

func (*RawTextContext) GetParser 

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

func (*RawTextContext) GetRuleContext 

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

func (*RawTextContext) IsRawTextContext 

func (*RawTextContext) IsRawTextContext()

func (*RawTextContext) ToStringTree 

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

type RawTextElementContext 

type RawTextElementContext struct {
	*ElementContext
}

func NewRawTextElementContext 

func NewRawTextElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RawTextElementContext

func (*RawTextElementContext) Accept 

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

func (*RawTextElementContext) GetRuleContext 

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

func (*RawTextElementContext) RawText 

func (s *RawTextElementContext) RawText() IRawTextContext

type SingleQuoteContext 

type SingleQuoteContext struct {
	*StringContext
}

func NewSingleQuoteContext 

func NewSingleQuoteContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SingleQuoteContext

func (*SingleQuoteContext) Accept 

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

func (*SingleQuoteContext) GetRuleContext 

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

func (*SingleQuoteContext) Single_quote_string 

func (s *SingleQuoteContext) Single_quote_string() ISingle_quote_stringContext

type Single_quote_stringContext 

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

func NewEmptySingle_quote_stringContext 

func NewEmptySingle_quote_stringContext() *Single_quote_stringContext

func NewSingle_quote_stringContext 

func NewSingle_quote_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_quote_stringContext

func (*Single_quote_stringContext) Accept 

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

func (*Single_quote_stringContext) AllEXPR_EXIT_R_BRACE 

func (s *Single_quote_stringContext) AllEXPR_EXIT_R_BRACE() []antlr.TerminalNode

func (*Single_quote_stringContext) AllExpr 

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

func (*Single_quote_stringContext) AllSQS_CONTENT 

func (s *Single_quote_stringContext) AllSQS_CONTENT() []antlr.TerminalNode

func (*Single_quote_stringContext) AllSQS_ENTER_EXPR 

func (s *Single_quote_stringContext) AllSQS_ENTER_EXPR() []antlr.TerminalNode

func (*Single_quote_stringContext) AllSQS_ESCAPE 

func (s *Single_quote_stringContext) AllSQS_ESCAPE() []antlr.TerminalNode

func (*Single_quote_stringContext) EXPR_EXIT_R_BRACE 

func (s *Single_quote_stringContext) EXPR_EXIT_R_BRACE(i int) antlr.TerminalNode

func (*Single_quote_stringContext) EXPR_SINGLE_STR_START 

func (s *Single_quote_stringContext) EXPR_SINGLE_STR_START() antlr.TerminalNode

func (*Single_quote_stringContext) Expr 

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

func (*Single_quote_stringContext) GetParser 

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

func (*Single_quote_stringContext) GetRuleContext 

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

func (*Single_quote_stringContext) IsSingle_quote_stringContext 

func (*Single_quote_stringContext) IsSingle_quote_stringContext()

func (*Single_quote_stringContext) SQS_CONTENT 

func (s *Single_quote_stringContext) SQS_CONTENT(i int) antlr.TerminalNode

func (*Single_quote_stringContext) SQS_ENTER_EXPR 

func (s *Single_quote_stringContext) SQS_ENTER_EXPR(i int) antlr.TerminalNode

func (*Single_quote_stringContext) SQS_ESCAPE 

func (s *Single_quote_stringContext) SQS_ESCAPE(i int) antlr.TerminalNode

func (*Single_quote_stringContext) SQS_EXIT 

func (s *Single_quote_stringContext) SQS_EXIT() antlr.TerminalNode

func (*Single_quote_stringContext) ToStringTree 

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

type StringContext 

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

func NewEmptyStringContext 

func NewEmptyStringContext() *StringContext

func NewStringContext 

func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringContext

func (*StringContext) CopyFrom 

func (s *StringContext) CopyFrom(ctx *StringContext)

func (*StringContext) GetParser 

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

func (*StringContext) GetRuleContext 

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

func (*StringContext) IsStringContext 

func (*StringContext) IsStringContext()

func (*StringContext) ToStringTree 

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

type StringExprContext 

type StringExprContext struct {
	*ExprContext
}

func NewStringExprContext 

func NewStringExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringExprContext

func (*StringExprContext) Accept 

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

func (*StringExprContext) GetRuleContext 

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

func (*StringExprContext) String_ 

func (s *StringExprContext) String_() IStringContext

type StructContext 

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

func NewEmptyStructContext 

func NewEmptyStructContext() *StructContext

func NewStructContext 

func NewStructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructContext

func (*StructContext) Accept 

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

func (*StructContext) AllEXPR_COMMA 

func (s *StructContext) AllEXPR_COMMA() []antlr.TerminalNode

func (*StructContext) AllStruct_pair 

func (s *StructContext) AllStruct_pair() []IStruct_pairContext

func (*StructContext) EXPR_COMMA 

func (s *StructContext) EXPR_COMMA(i int) antlr.TerminalNode

func (*StructContext) EXPR_EXIT_R_BRACE 

func (s *StructContext) EXPR_EXIT_R_BRACE() antlr.TerminalNode

func (*StructContext) EXPR_STRUCT 

func (s *StructContext) EXPR_STRUCT() antlr.TerminalNode

func (*StructContext) GetParser 

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

func (*StructContext) GetRuleContext 

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

func (*StructContext) IsStructContext 

func (*StructContext) IsStructContext()

func (*StructContext) Struct_pair 

func (s *StructContext) Struct_pair(i int) IStruct_pairContext

func (*StructContext) ToStringTree 

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

type StructExprContext 

type StructExprContext struct {
	*ExprContext
}

func NewStructExprContext 

func NewStructExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StructExprContext

func (*StructExprContext) Accept 

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

func (*StructExprContext) GetRuleContext 

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

func (*StructExprContext) Struct_ 

func (s *StructExprContext) Struct_() IStructContext

type Struct_pairContext 

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

func NewEmptyStruct_pairContext 

func NewEmptyStruct_pairContext() *Struct_pairContext

func NewStruct_pairContext 

func NewStruct_pairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_pairContext

func (*Struct_pairContext) Accept 

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

func (*Struct_pairContext) EXPR_COLON 

func (s *Struct_pairContext) EXPR_COLON() antlr.TerminalNode

func (*Struct_pairContext) EXPR_SYMBOL 

func (s *Struct_pairContext) EXPR_SYMBOL() antlr.TerminalNode

func (*Struct_pairContext) Expr 

func (s *Struct_pairContext) Expr() IExprContext

func (*Struct_pairContext) GetParser 

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

func (*Struct_pairContext) GetRuleContext 

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

func (*Struct_pairContext) IsStruct_pairContext 

func (*Struct_pairContext) IsStruct_pairContext()

func (*Struct_pairContext) String_ 

func (s *Struct_pairContext) String_() IStringContext

func (*Struct_pairContext) ToStringTree 

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

type SymbolExprContext 

type SymbolExprContext struct {
	*ExprContext
}

func NewSymbolExprContext 

func NewSymbolExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SymbolExprContext

func (*SymbolExprContext) Accept 

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

func (*SymbolExprContext) EXPR_SYMBOL 

func (s *SymbolExprContext) EXPR_SYMBOL() antlr.TerminalNode

func (*SymbolExprContext) GetRuleContext 

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

type TagExprContext 

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

func NewEmptyTagExprContext 

func NewEmptyTagExprContext() *TagExprContext

func NewTagExprContext 

func NewTagExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TagExprContext

func (*TagExprContext) Accept 

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

func (*TagExprContext) Expr 

func (s *TagExprContext) Expr() IExprContext

func (*TagExprContext) GetParser 

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

func (*TagExprContext) GetRuleContext 

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

func (*TagExprContext) IsTagExprContext 

func (*TagExprContext) IsTagExprContext()

func (*TagExprContext) ToStringTree 

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

type TagExprElseIfsContext 

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

func NewEmptyTagExprElseIfsContext 

func NewEmptyTagExprElseIfsContext() *TagExprElseIfsContext

func NewTagExprElseIfsContext 

func NewTagExprElseIfsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TagExprElseIfsContext

func (*TagExprElseIfsContext) Accept 

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

func (*TagExprElseIfsContext) GetParser 

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

func (*TagExprElseIfsContext) GetRuleContext 

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

func (*TagExprElseIfsContext) IsTagExprElseIfsContext 

func (*TagExprElseIfsContext) IsTagExprElseIfsContext()

func (*TagExprElseIfsContext) TagExpr 

func (s *TagExprElseIfsContext) TagExpr() ITagExprContext

func (*TagExprElseIfsContext) ToStringTree 

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

type TemplateContext 

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

func NewEmptyTemplateContext 

func NewEmptyTemplateContext() *TemplateContext

func NewTemplateContext 

func NewTemplateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateContext

func (*TemplateContext) Accept 

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

func (*TemplateContext) EOF 

func (s *TemplateContext) EOF() antlr.TerminalNode

func (*TemplateContext) Elements 

func (s *TemplateContext) Elements() IElementsContext

func (*TemplateContext) GetParser 

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

func (*TemplateContext) GetRuleContext 

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

func (*TemplateContext) IsTemplateContext 

func (*TemplateContext) IsTemplateContext()

func (*TemplateContext) ToStringTree 

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

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.