fql

package
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: Oct 14, 2018 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	FqlLexerMultiLineComment  = 1
	FqlLexerSingleLineComment = 2
	FqlLexerWhiteSpaces       = 3
	FqlLexerLineTerminator    = 4
	FqlLexerColon             = 5
	FqlLexerSemiColon         = 6
	FqlLexerDot               = 7
	FqlLexerComma             = 8
	FqlLexerOpenBracket       = 9
	FqlLexerCloseBracket      = 10
	FqlLexerOpenParen         = 11
	FqlLexerCloseParen        = 12
	FqlLexerOpenBrace         = 13
	FqlLexerCloseBrace        = 14
	FqlLexerGt                = 15
	FqlLexerLt                = 16
	FqlLexerEq                = 17
	FqlLexerGte               = 18
	FqlLexerLte               = 19
	FqlLexerNeq               = 20
	FqlLexerPlus              = 21
	FqlLexerMinus             = 22
	FqlLexerMinusMinus        = 23
	FqlLexerPlusPlus          = 24
	FqlLexerMulti             = 25
	FqlLexerDiv               = 26
	FqlLexerMod               = 27
	FqlLexerAnd               = 28
	FqlLexerOr                = 29
	FqlLexerRange             = 30
	FqlLexerAssign            = 31
	FqlLexerQuestionMark      = 32
	FqlLexerRegexNotMatch     = 33
	FqlLexerRegexMatch        = 34
	FqlLexerFor               = 35
	FqlLexerReturn            = 36
	FqlLexerDistinct          = 37
	FqlLexerFilter            = 38
	FqlLexerSort              = 39
	FqlLexerLimit             = 40
	FqlLexerLet               = 41
	FqlLexerCollect           = 42
	FqlLexerSortDirection     = 43
	FqlLexerNone              = 44
	FqlLexerNull              = 45
	FqlLexerBooleanLiteral    = 46
	FqlLexerInto              = 47
	FqlLexerKeep              = 48
	FqlLexerWith              = 49
	FqlLexerCount             = 50
	FqlLexerAll               = 51
	FqlLexerAny               = 52
	FqlLexerAggregate         = 53
	FqlLexerLike              = 54
	FqlLexerNot               = 55
	FqlLexerIn                = 56
	FqlLexerParam             = 57
	FqlLexerIdentifier        = 58
	FqlLexerStringLiteral     = 59
	FqlLexerIntegerLiteral    = 60
	FqlLexerFloatLiteral      = 61
)

FqlLexer tokens.

View Source 
const (
	FqlParserEOF               = antlr.TokenEOF
	FqlParserMultiLineComment  = 1
	FqlParserSingleLineComment = 2
	FqlParserWhiteSpaces       = 3
	FqlParserLineTerminator    = 4
	FqlParserColon             = 5
	FqlParserSemiColon         = 6
	FqlParserDot               = 7
	FqlParserComma             = 8
	FqlParserOpenBracket       = 9
	FqlParserCloseBracket      = 10
	FqlParserOpenParen         = 11
	FqlParserCloseParen        = 12
	FqlParserOpenBrace         = 13
	FqlParserCloseBrace        = 14
	FqlParserGt                = 15
	FqlParserLt                = 16
	FqlParserEq                = 17
	FqlParserGte               = 18
	FqlParserLte               = 19
	FqlParserNeq               = 20
	FqlParserPlus              = 21
	FqlParserMinus             = 22
	FqlParserMinusMinus        = 23
	FqlParserPlusPlus          = 24
	FqlParserMulti             = 25
	FqlParserDiv               = 26
	FqlParserMod               = 27
	FqlParserAnd               = 28
	FqlParserOr                = 29
	FqlParserRange             = 30
	FqlParserAssign            = 31
	FqlParserQuestionMark      = 32
	FqlParserRegexNotMatch     = 33
	FqlParserRegexMatch        = 34
	FqlParserFor               = 35
	FqlParserReturn            = 36
	FqlParserDistinct          = 37
	FqlParserFilter            = 38
	FqlParserSort              = 39
	FqlParserLimit             = 40
	FqlParserLet               = 41
	FqlParserCollect           = 42
	FqlParserSortDirection     = 43
	FqlParserNone              = 44
	FqlParserNull              = 45
	FqlParserBooleanLiteral    = 46
	FqlParserInto              = 47
	FqlParserKeep              = 48
	FqlParserWith              = 49
	FqlParserCount             = 50
	FqlParserAll               = 51
	FqlParserAny               = 52
	FqlParserAggregate         = 53
	FqlParserLike              = 54
	FqlParserNot               = 55
	FqlParserIn                = 56
	FqlParserParam             = 57
	FqlParserIdentifier        = 58
	FqlParserStringLiteral     = 59
	FqlParserIntegerLiteral    = 60
	FqlParserFloatLiteral      = 61
)

FqlParser tokens.

View Source 
const (
	FqlParserRULE_program                    = 0
	FqlParserRULE_body                       = 1
	FqlParserRULE_bodyStatement              = 2
	FqlParserRULE_bodyExpression             = 3
	FqlParserRULE_returnExpression           = 4
	FqlParserRULE_forExpression              = 5
	FqlParserRULE_forExpressionValueVariable = 6
	FqlParserRULE_forExpressionKeyVariable   = 7
	FqlParserRULE_forExpressionSource        = 8
	FqlParserRULE_forExpressionClause        = 9
	FqlParserRULE_filterClause               = 10
	FqlParserRULE_limitClause                = 11
	FqlParserRULE_sortClause                 = 12
	FqlParserRULE_sortClauseExpression       = 13
	FqlParserRULE_collectClause              = 14
	FqlParserRULE_collectVariable            = 15
	FqlParserRULE_collectGroupVariable       = 16
	FqlParserRULE_collectKeepVariable        = 17
	FqlParserRULE_collectCountVariable       = 18
	FqlParserRULE_collectAggregateVariable   = 19
	FqlParserRULE_collectAggregateExpression = 20
	FqlParserRULE_collectOption              = 21
	FqlParserRULE_forExpressionBody          = 22
	FqlParserRULE_forExpressionReturn        = 23
	FqlParserRULE_variableDeclaration        = 24
	FqlParserRULE_param                      = 25
	FqlParserRULE_variable                   = 26
	FqlParserRULE_rangeOperator              = 27
	FqlParserRULE_arrayLiteral               = 28
	FqlParserRULE_objectLiteral              = 29
	FqlParserRULE_booleanLiteral             = 30
	FqlParserRULE_stringLiteral              = 31
	FqlParserRULE_integerLiteral             = 32
	FqlParserRULE_floatLiteral               = 33
	FqlParserRULE_noneLiteral                = 34
	FqlParserRULE_arrayElementList           = 35
	FqlParserRULE_propertyAssignment         = 36
	FqlParserRULE_memberExpression           = 37
	FqlParserRULE_shorthandPropertyName      = 38
	FqlParserRULE_computedPropertyName       = 39
	FqlParserRULE_propertyName               = 40
	FqlParserRULE_expressionSequence         = 41
	FqlParserRULE_functionCallExpression     = 42
	FqlParserRULE_arguments                  = 43
	FqlParserRULE_expression                 = 44
	FqlParserRULE_forTernaryExpression       = 45
	FqlParserRULE_arrayOperator              = 46
	FqlParserRULE_inOperator                 = 47
	FqlParserRULE_equalityOperator           = 48
	FqlParserRULE_logicalOperator            = 49
	FqlParserRULE_mathOperator               = 50
	FqlParserRULE_unaryOperator              = 51
)

FqlParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type ArgumentsContext 

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

func NewArgumentsContext 

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

func NewEmptyArgumentsContext 

func NewEmptyArgumentsContext() *ArgumentsContext

func (*ArgumentsContext) Accept 

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

func (*ArgumentsContext) AllComma 

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

func (*ArgumentsContext) AllExpression 

func (s *ArgumentsContext) AllExpression() []IExpressionContext

func (*ArgumentsContext) CloseParen 

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

func (*ArgumentsContext) Comma 

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

func (*ArgumentsContext) EnterRule 

func (s *ArgumentsContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArgumentsContext) ExitRule 

func (s *ArgumentsContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArgumentsContext) Expression 

func (s *ArgumentsContext) Expression(i int) IExpressionContext

func (*ArgumentsContext) GetParser 

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

func (*ArgumentsContext) GetRuleContext 

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

func (*ArgumentsContext) IsArgumentsContext 

func (*ArgumentsContext) IsArgumentsContext()

func (*ArgumentsContext) OpenParen 

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

func (*ArgumentsContext) ToStringTree 

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

type ArrayElementListContext 

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

func NewArrayElementListContext 

func NewArrayElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementListContext

func NewEmptyArrayElementListContext 

func NewEmptyArrayElementListContext() *ArrayElementListContext

func (*ArrayElementListContext) Accept 

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

func (*ArrayElementListContext) AllComma 

func (s *ArrayElementListContext) AllComma() []antlr.TerminalNode

func (*ArrayElementListContext) AllExpression 

func (s *ArrayElementListContext) AllExpression() []IExpressionContext

func (*ArrayElementListContext) Comma 

func (s *ArrayElementListContext) Comma(i int) antlr.TerminalNode

func (*ArrayElementListContext) EnterRule 

func (s *ArrayElementListContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayElementListContext) ExitRule 

func (s *ArrayElementListContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayElementListContext) Expression 

func (s *ArrayElementListContext) Expression(i int) IExpressionContext

func (*ArrayElementListContext) GetParser 

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

func (*ArrayElementListContext) GetRuleContext 

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

func (*ArrayElementListContext) IsArrayElementListContext 

func (*ArrayElementListContext) IsArrayElementListContext()

func (*ArrayElementListContext) ToStringTree 

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

type ArrayLiteralContext 

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

func NewArrayLiteralContext 

func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext

func NewEmptyArrayLiteralContext 

func NewEmptyArrayLiteralContext() *ArrayLiteralContext

func (*ArrayLiteralContext) Accept 

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

func (*ArrayLiteralContext) ArrayElementList 

func (s *ArrayLiteralContext) ArrayElementList() IArrayElementListContext

func (*ArrayLiteralContext) CloseBracket 

func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode

func (*ArrayLiteralContext) EnterRule 

func (s *ArrayLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayLiteralContext) ExitRule 

func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayLiteralContext) GetParser 

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

func (*ArrayLiteralContext) GetRuleContext 

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

func (*ArrayLiteralContext) IsArrayLiteralContext 

func (*ArrayLiteralContext) IsArrayLiteralContext()

func (*ArrayLiteralContext) OpenBracket 

func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode

func (*ArrayLiteralContext) ToStringTree 

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

type ArrayOperatorContext 

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

func NewArrayOperatorContext 

func NewArrayOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayOperatorContext

func NewEmptyArrayOperatorContext 

func NewEmptyArrayOperatorContext() *ArrayOperatorContext

func (*ArrayOperatorContext) Accept 

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

func (*ArrayOperatorContext) All 

func (s *ArrayOperatorContext) All() antlr.TerminalNode

func (*ArrayOperatorContext) Any 

func (s *ArrayOperatorContext) Any() antlr.TerminalNode

func (*ArrayOperatorContext) EnterRule 

func (s *ArrayOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayOperatorContext) ExitRule 

func (s *ArrayOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayOperatorContext) GetParser 

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

func (*ArrayOperatorContext) GetRuleContext 

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

func (*ArrayOperatorContext) IsArrayOperatorContext 

func (*ArrayOperatorContext) IsArrayOperatorContext()

func (*ArrayOperatorContext) None 

func (s *ArrayOperatorContext) None() antlr.TerminalNode

func (*ArrayOperatorContext) ToStringTree 

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

type BaseFqlParserListener 

type BaseFqlParserListener struct{}

BaseFqlParserListener is a complete listener for a parse tree produced by FqlParser.

func (*BaseFqlParserListener) EnterArguments 

func (s *BaseFqlParserListener) EnterArguments(ctx *ArgumentsContext)

EnterArguments is called when production arguments is entered.

func (*BaseFqlParserListener) EnterArrayElementList 

func (s *BaseFqlParserListener) EnterArrayElementList(ctx *ArrayElementListContext)

EnterArrayElementList is called when production arrayElementList is entered.

func (*BaseFqlParserListener) EnterArrayLiteral 

func (s *BaseFqlParserListener) EnterArrayLiteral(ctx *ArrayLiteralContext)

EnterArrayLiteral is called when production arrayLiteral is entered.

func (*BaseFqlParserListener) EnterArrayOperator 

func (s *BaseFqlParserListener) EnterArrayOperator(ctx *ArrayOperatorContext)

EnterArrayOperator is called when production arrayOperator is entered.

func (*BaseFqlParserListener) EnterBody 

func (s *BaseFqlParserListener) EnterBody(ctx *BodyContext)

EnterBody is called when production body is entered.

func (*BaseFqlParserListener) EnterBodyExpression 

func (s *BaseFqlParserListener) EnterBodyExpression(ctx *BodyExpressionContext)

EnterBodyExpression is called when production bodyExpression is entered.

func (*BaseFqlParserListener) EnterBodyStatement 

func (s *BaseFqlParserListener) EnterBodyStatement(ctx *BodyStatementContext)

EnterBodyStatement is called when production bodyStatement is entered.

func (*BaseFqlParserListener) EnterBooleanLiteral 

func (s *BaseFqlParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

EnterBooleanLiteral is called when production booleanLiteral is entered.

func (*BaseFqlParserListener) EnterCollectAggregateExpression 

func (s *BaseFqlParserListener) EnterCollectAggregateExpression(ctx *CollectAggregateExpressionContext)

EnterCollectAggregateExpression is called when production collectAggregateExpression is entered.

func (*BaseFqlParserListener) EnterCollectAggregateVariable 

func (s *BaseFqlParserListener) EnterCollectAggregateVariable(ctx *CollectAggregateVariableContext)

EnterCollectAggregateVariable is called when production collectAggregateVariable is entered.

func (*BaseFqlParserListener) EnterCollectClause 

func (s *BaseFqlParserListener) EnterCollectClause(ctx *CollectClauseContext)

EnterCollectClause is called when production collectClause is entered.

func (*BaseFqlParserListener) EnterCollectCountVariable 

func (s *BaseFqlParserListener) EnterCollectCountVariable(ctx *CollectCountVariableContext)

EnterCollectCountVariable is called when production collectCountVariable is entered.

func (*BaseFqlParserListener) EnterCollectGroupVariable 

func (s *BaseFqlParserListener) EnterCollectGroupVariable(ctx *CollectGroupVariableContext)

EnterCollectGroupVariable is called when production collectGroupVariable is entered.

func (*BaseFqlParserListener) EnterCollectKeepVariable 

func (s *BaseFqlParserListener) EnterCollectKeepVariable(ctx *CollectKeepVariableContext)

EnterCollectKeepVariable is called when production collectKeepVariable is entered.

func (*BaseFqlParserListener) EnterCollectOption 

func (s *BaseFqlParserListener) EnterCollectOption(ctx *CollectOptionContext)

EnterCollectOption is called when production collectOption is entered.

func (*BaseFqlParserListener) EnterCollectVariable 

func (s *BaseFqlParserListener) EnterCollectVariable(ctx *CollectVariableContext)

EnterCollectVariable is called when production collectVariable is entered.

func (*BaseFqlParserListener) EnterComputedPropertyName 

func (s *BaseFqlParserListener) EnterComputedPropertyName(ctx *ComputedPropertyNameContext)

EnterComputedPropertyName is called when production computedPropertyName is entered.

func (*BaseFqlParserListener) EnterEqualityOperator 

func (s *BaseFqlParserListener) EnterEqualityOperator(ctx *EqualityOperatorContext)

EnterEqualityOperator is called when production equalityOperator is entered.

func (*BaseFqlParserListener) EnterEveryRule 

func (s *BaseFqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

EnterEveryRule is called when any rule is entered.

func (*BaseFqlParserListener) EnterExpression 

func (s *BaseFqlParserListener) EnterExpression(ctx *ExpressionContext)

EnterExpression is called when production expression is entered.

func (*BaseFqlParserListener) EnterExpressionSequence 

func (s *BaseFqlParserListener) EnterExpressionSequence(ctx *ExpressionSequenceContext)

EnterExpressionSequence is called when production expressionSequence is entered.

func (*BaseFqlParserListener) EnterFilterClause 

func (s *BaseFqlParserListener) EnterFilterClause(ctx *FilterClauseContext)

EnterFilterClause is called when production filterClause is entered.

func (*BaseFqlParserListener) EnterFloatLiteral 

func (s *BaseFqlParserListener) EnterFloatLiteral(ctx *FloatLiteralContext)

EnterFloatLiteral is called when production floatLiteral is entered.

func (*BaseFqlParserListener) EnterForExpression 

func (s *BaseFqlParserListener) EnterForExpression(ctx *ForExpressionContext)

EnterForExpression is called when production forExpression is entered.

func (*BaseFqlParserListener) EnterForExpressionBody 

func (s *BaseFqlParserListener) EnterForExpressionBody(ctx *ForExpressionBodyContext)

EnterForExpressionBody is called when production forExpressionBody is entered.

func (*BaseFqlParserListener) EnterForExpressionClause 

func (s *BaseFqlParserListener) EnterForExpressionClause(ctx *ForExpressionClauseContext)

EnterForExpressionClause is called when production forExpressionClause is entered.

func (*BaseFqlParserListener) EnterForExpressionKeyVariable 

func (s *BaseFqlParserListener) EnterForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

EnterForExpressionKeyVariable is called when production forExpressionKeyVariable is entered.

func (*BaseFqlParserListener) EnterForExpressionReturn 

func (s *BaseFqlParserListener) EnterForExpressionReturn(ctx *ForExpressionReturnContext)

EnterForExpressionReturn is called when production forExpressionReturn is entered.

func (*BaseFqlParserListener) EnterForExpressionSource 

func (s *BaseFqlParserListener) EnterForExpressionSource(ctx *ForExpressionSourceContext)

EnterForExpressionSource is called when production forExpressionSource is entered.

func (*BaseFqlParserListener) EnterForExpressionValueVariable 

func (s *BaseFqlParserListener) EnterForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

EnterForExpressionValueVariable is called when production forExpressionValueVariable is entered.

func (*BaseFqlParserListener) EnterForTernaryExpression 

func (s *BaseFqlParserListener) EnterForTernaryExpression(ctx *ForTernaryExpressionContext)

EnterForTernaryExpression is called when production forTernaryExpression is entered.

func (*BaseFqlParserListener) EnterFunctionCallExpression 

func (s *BaseFqlParserListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext)

EnterFunctionCallExpression is called when production functionCallExpression is entered.

func (*BaseFqlParserListener) EnterInOperator 

func (s *BaseFqlParserListener) EnterInOperator(ctx *InOperatorContext)

EnterInOperator is called when production inOperator is entered.

func (*BaseFqlParserListener) EnterIntegerLiteral 

func (s *BaseFqlParserListener) EnterIntegerLiteral(ctx *IntegerLiteralContext)

EnterIntegerLiteral is called when production integerLiteral is entered.

func (*BaseFqlParserListener) EnterLimitClause 

func (s *BaseFqlParserListener) EnterLimitClause(ctx *LimitClauseContext)

EnterLimitClause is called when production limitClause is entered.

func (*BaseFqlParserListener) EnterLogicalOperator 

func (s *BaseFqlParserListener) EnterLogicalOperator(ctx *LogicalOperatorContext)

EnterLogicalOperator is called when production logicalOperator is entered.

func (*BaseFqlParserListener) EnterMathOperator 

func (s *BaseFqlParserListener) EnterMathOperator(ctx *MathOperatorContext)

EnterMathOperator is called when production mathOperator is entered.

func (*BaseFqlParserListener) EnterMemberExpression 

func (s *BaseFqlParserListener) EnterMemberExpression(ctx *MemberExpressionContext)

EnterMemberExpression is called when production memberExpression is entered.

func (*BaseFqlParserListener) EnterNoneLiteral 

func (s *BaseFqlParserListener) EnterNoneLiteral(ctx *NoneLiteralContext)

EnterNoneLiteral is called when production noneLiteral is entered.

func (*BaseFqlParserListener) EnterObjectLiteral 

func (s *BaseFqlParserListener) EnterObjectLiteral(ctx *ObjectLiteralContext)

EnterObjectLiteral is called when production objectLiteral is entered.

func (*BaseFqlParserListener) EnterParam 

func (s *BaseFqlParserListener) EnterParam(ctx *ParamContext)

EnterParam is called when production param is entered.

func (*BaseFqlParserListener) EnterProgram 

func (s *BaseFqlParserListener) EnterProgram(ctx *ProgramContext)

EnterProgram is called when production program is entered.

func (*BaseFqlParserListener) EnterPropertyAssignment 

func (s *BaseFqlParserListener) EnterPropertyAssignment(ctx *PropertyAssignmentContext)

EnterPropertyAssignment is called when production propertyAssignment is entered.

func (*BaseFqlParserListener) EnterPropertyName 

func (s *BaseFqlParserListener) EnterPropertyName(ctx *PropertyNameContext)

EnterPropertyName is called when production propertyName is entered.

func (*BaseFqlParserListener) EnterRangeOperator 

func (s *BaseFqlParserListener) EnterRangeOperator(ctx *RangeOperatorContext)

EnterRangeOperator is called when production rangeOperator is entered.

func (*BaseFqlParserListener) EnterReturnExpression 

func (s *BaseFqlParserListener) EnterReturnExpression(ctx *ReturnExpressionContext)

EnterReturnExpression is called when production returnExpression is entered.

func (*BaseFqlParserListener) EnterShorthandPropertyName 

func (s *BaseFqlParserListener) EnterShorthandPropertyName(ctx *ShorthandPropertyNameContext)

EnterShorthandPropertyName is called when production shorthandPropertyName is entered.

func (*BaseFqlParserListener) EnterSortClause 

func (s *BaseFqlParserListener) EnterSortClause(ctx *SortClauseContext)

EnterSortClause is called when production sortClause is entered.

func (*BaseFqlParserListener) EnterSortClauseExpression 

func (s *BaseFqlParserListener) EnterSortClauseExpression(ctx *SortClauseExpressionContext)

EnterSortClauseExpression is called when production sortClauseExpression is entered.

func (*BaseFqlParserListener) EnterStringLiteral 

func (s *BaseFqlParserListener) EnterStringLiteral(ctx *StringLiteralContext)

EnterStringLiteral is called when production stringLiteral is entered.

func (*BaseFqlParserListener) EnterUnaryOperator 

func (s *BaseFqlParserListener) EnterUnaryOperator(ctx *UnaryOperatorContext)

EnterUnaryOperator is called when production unaryOperator is entered.

func (*BaseFqlParserListener) EnterVariable 

func (s *BaseFqlParserListener) EnterVariable(ctx *VariableContext)

EnterVariable is called when production variable is entered.

func (*BaseFqlParserListener) EnterVariableDeclaration 

func (s *BaseFqlParserListener) EnterVariableDeclaration(ctx *VariableDeclarationContext)

EnterVariableDeclaration is called when production variableDeclaration is entered.

func (*BaseFqlParserListener) ExitArguments 

func (s *BaseFqlParserListener) ExitArguments(ctx *ArgumentsContext)

ExitArguments is called when production arguments is exited.

func (*BaseFqlParserListener) ExitArrayElementList 

func (s *BaseFqlParserListener) ExitArrayElementList(ctx *ArrayElementListContext)

ExitArrayElementList is called when production arrayElementList is exited.

func (*BaseFqlParserListener) ExitArrayLiteral 

func (s *BaseFqlParserListener) ExitArrayLiteral(ctx *ArrayLiteralContext)

ExitArrayLiteral is called when production arrayLiteral is exited.

func (*BaseFqlParserListener) ExitArrayOperator 

func (s *BaseFqlParserListener) ExitArrayOperator(ctx *ArrayOperatorContext)

ExitArrayOperator is called when production arrayOperator is exited.

func (*BaseFqlParserListener) ExitBody 

func (s *BaseFqlParserListener) ExitBody(ctx *BodyContext)

ExitBody is called when production body is exited.

func (*BaseFqlParserListener) ExitBodyExpression 

func (s *BaseFqlParserListener) ExitBodyExpression(ctx *BodyExpressionContext)

ExitBodyExpression is called when production bodyExpression is exited.

func (*BaseFqlParserListener) ExitBodyStatement 

func (s *BaseFqlParserListener) ExitBodyStatement(ctx *BodyStatementContext)

ExitBodyStatement is called when production bodyStatement is exited.

func (*BaseFqlParserListener) ExitBooleanLiteral 

func (s *BaseFqlParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

ExitBooleanLiteral is called when production booleanLiteral is exited.

func (*BaseFqlParserListener) ExitCollectAggregateExpression 

func (s *BaseFqlParserListener) ExitCollectAggregateExpression(ctx *CollectAggregateExpressionContext)

ExitCollectAggregateExpression is called when production collectAggregateExpression is exited.

func (*BaseFqlParserListener) ExitCollectAggregateVariable 

func (s *BaseFqlParserListener) ExitCollectAggregateVariable(ctx *CollectAggregateVariableContext)

ExitCollectAggregateVariable is called when production collectAggregateVariable is exited.

func (*BaseFqlParserListener) ExitCollectClause 

func (s *BaseFqlParserListener) ExitCollectClause(ctx *CollectClauseContext)

ExitCollectClause is called when production collectClause is exited.

func (*BaseFqlParserListener) ExitCollectCountVariable 

func (s *BaseFqlParserListener) ExitCollectCountVariable(ctx *CollectCountVariableContext)

ExitCollectCountVariable is called when production collectCountVariable is exited.

func (*BaseFqlParserListener) ExitCollectGroupVariable 

func (s *BaseFqlParserListener) ExitCollectGroupVariable(ctx *CollectGroupVariableContext)

ExitCollectGroupVariable is called when production collectGroupVariable is exited.

func (*BaseFqlParserListener) ExitCollectKeepVariable 

func (s *BaseFqlParserListener) ExitCollectKeepVariable(ctx *CollectKeepVariableContext)

ExitCollectKeepVariable is called when production collectKeepVariable is exited.

func (*BaseFqlParserListener) ExitCollectOption 

func (s *BaseFqlParserListener) ExitCollectOption(ctx *CollectOptionContext)

ExitCollectOption is called when production collectOption is exited.

func (*BaseFqlParserListener) ExitCollectVariable 

func (s *BaseFqlParserListener) ExitCollectVariable(ctx *CollectVariableContext)

ExitCollectVariable is called when production collectVariable is exited.

func (*BaseFqlParserListener) ExitComputedPropertyName 

func (s *BaseFqlParserListener) ExitComputedPropertyName(ctx *ComputedPropertyNameContext)

ExitComputedPropertyName is called when production computedPropertyName is exited.

func (*BaseFqlParserListener) ExitEqualityOperator 

func (s *BaseFqlParserListener) ExitEqualityOperator(ctx *EqualityOperatorContext)

ExitEqualityOperator is called when production equalityOperator is exited.

func (*BaseFqlParserListener) ExitEveryRule 

func (s *BaseFqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

ExitEveryRule is called when any rule is exited.

func (*BaseFqlParserListener) ExitExpression 

func (s *BaseFqlParserListener) ExitExpression(ctx *ExpressionContext)

ExitExpression is called when production expression is exited.

func (*BaseFqlParserListener) ExitExpressionSequence 

func (s *BaseFqlParserListener) ExitExpressionSequence(ctx *ExpressionSequenceContext)

ExitExpressionSequence is called when production expressionSequence is exited.

func (*BaseFqlParserListener) ExitFilterClause 

func (s *BaseFqlParserListener) ExitFilterClause(ctx *FilterClauseContext)

ExitFilterClause is called when production filterClause is exited.

func (*BaseFqlParserListener) ExitFloatLiteral 

func (s *BaseFqlParserListener) ExitFloatLiteral(ctx *FloatLiteralContext)

ExitFloatLiteral is called when production floatLiteral is exited.

func (*BaseFqlParserListener) ExitForExpression 

func (s *BaseFqlParserListener) ExitForExpression(ctx *ForExpressionContext)

ExitForExpression is called when production forExpression is exited.

func (*BaseFqlParserListener) ExitForExpressionBody 

func (s *BaseFqlParserListener) ExitForExpressionBody(ctx *ForExpressionBodyContext)

ExitForExpressionBody is called when production forExpressionBody is exited.

func (*BaseFqlParserListener) ExitForExpressionClause 

func (s *BaseFqlParserListener) ExitForExpressionClause(ctx *ForExpressionClauseContext)

ExitForExpressionClause is called when production forExpressionClause is exited.

func (*BaseFqlParserListener) ExitForExpressionKeyVariable 

func (s *BaseFqlParserListener) ExitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

ExitForExpressionKeyVariable is called when production forExpressionKeyVariable is exited.

func (*BaseFqlParserListener) ExitForExpressionReturn 

func (s *BaseFqlParserListener) ExitForExpressionReturn(ctx *ForExpressionReturnContext)

ExitForExpressionReturn is called when production forExpressionReturn is exited.

func (*BaseFqlParserListener) ExitForExpressionSource 

func (s *BaseFqlParserListener) ExitForExpressionSource(ctx *ForExpressionSourceContext)

ExitForExpressionSource is called when production forExpressionSource is exited.

func (*BaseFqlParserListener) ExitForExpressionValueVariable 

func (s *BaseFqlParserListener) ExitForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

ExitForExpressionValueVariable is called when production forExpressionValueVariable is exited.

func (*BaseFqlParserListener) ExitForTernaryExpression 

func (s *BaseFqlParserListener) ExitForTernaryExpression(ctx *ForTernaryExpressionContext)

ExitForTernaryExpression is called when production forTernaryExpression is exited.

func (*BaseFqlParserListener) ExitFunctionCallExpression 

func (s *BaseFqlParserListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext)

ExitFunctionCallExpression is called when production functionCallExpression is exited.

func (*BaseFqlParserListener) ExitInOperator 

func (s *BaseFqlParserListener) ExitInOperator(ctx *InOperatorContext)

ExitInOperator is called when production inOperator is exited.

func (*BaseFqlParserListener) ExitIntegerLiteral 

func (s *BaseFqlParserListener) ExitIntegerLiteral(ctx *IntegerLiteralContext)

ExitIntegerLiteral is called when production integerLiteral is exited.

func (*BaseFqlParserListener) ExitLimitClause 

func (s *BaseFqlParserListener) ExitLimitClause(ctx *LimitClauseContext)

ExitLimitClause is called when production limitClause is exited.

func (*BaseFqlParserListener) ExitLogicalOperator 

func (s *BaseFqlParserListener) ExitLogicalOperator(ctx *LogicalOperatorContext)

ExitLogicalOperator is called when production logicalOperator is exited.

func (*BaseFqlParserListener) ExitMathOperator 

func (s *BaseFqlParserListener) ExitMathOperator(ctx *MathOperatorContext)

ExitMathOperator is called when production mathOperator is exited.

func (*BaseFqlParserListener) ExitMemberExpression 

func (s *BaseFqlParserListener) ExitMemberExpression(ctx *MemberExpressionContext)

ExitMemberExpression is called when production memberExpression is exited.

func (*BaseFqlParserListener) ExitNoneLiteral 

func (s *BaseFqlParserListener) ExitNoneLiteral(ctx *NoneLiteralContext)

ExitNoneLiteral is called when production noneLiteral is exited.

func (*BaseFqlParserListener) ExitObjectLiteral 

func (s *BaseFqlParserListener) ExitObjectLiteral(ctx *ObjectLiteralContext)

ExitObjectLiteral is called when production objectLiteral is exited.

func (*BaseFqlParserListener) ExitParam 

func (s *BaseFqlParserListener) ExitParam(ctx *ParamContext)

ExitParam is called when production param is exited.

func (*BaseFqlParserListener) ExitProgram 

func (s *BaseFqlParserListener) ExitProgram(ctx *ProgramContext)

ExitProgram is called when production program is exited.

func (*BaseFqlParserListener) ExitPropertyAssignment 

func (s *BaseFqlParserListener) ExitPropertyAssignment(ctx *PropertyAssignmentContext)

ExitPropertyAssignment is called when production propertyAssignment is exited.

func (*BaseFqlParserListener) ExitPropertyName 

func (s *BaseFqlParserListener) ExitPropertyName(ctx *PropertyNameContext)

ExitPropertyName is called when production propertyName is exited.

func (*BaseFqlParserListener) ExitRangeOperator 

func (s *BaseFqlParserListener) ExitRangeOperator(ctx *RangeOperatorContext)

ExitRangeOperator is called when production rangeOperator is exited.

func (*BaseFqlParserListener) ExitReturnExpression 

func (s *BaseFqlParserListener) ExitReturnExpression(ctx *ReturnExpressionContext)

ExitReturnExpression is called when production returnExpression is exited.

func (*BaseFqlParserListener) ExitShorthandPropertyName 

func (s *BaseFqlParserListener) ExitShorthandPropertyName(ctx *ShorthandPropertyNameContext)

ExitShorthandPropertyName is called when production shorthandPropertyName is exited.

func (*BaseFqlParserListener) ExitSortClause 

func (s *BaseFqlParserListener) ExitSortClause(ctx *SortClauseContext)

ExitSortClause is called when production sortClause is exited.

func (*BaseFqlParserListener) ExitSortClauseExpression 

func (s *BaseFqlParserListener) ExitSortClauseExpression(ctx *SortClauseExpressionContext)

ExitSortClauseExpression is called when production sortClauseExpression is exited.

func (*BaseFqlParserListener) ExitStringLiteral 

func (s *BaseFqlParserListener) ExitStringLiteral(ctx *StringLiteralContext)

ExitStringLiteral is called when production stringLiteral is exited.

func (*BaseFqlParserListener) ExitUnaryOperator 

func (s *BaseFqlParserListener) ExitUnaryOperator(ctx *UnaryOperatorContext)

ExitUnaryOperator is called when production unaryOperator is exited.

func (*BaseFqlParserListener) ExitVariable 

func (s *BaseFqlParserListener) ExitVariable(ctx *VariableContext)

ExitVariable is called when production variable is exited.

func (*BaseFqlParserListener) ExitVariableDeclaration 

func (s *BaseFqlParserListener) ExitVariableDeclaration(ctx *VariableDeclarationContext)

ExitVariableDeclaration is called when production variableDeclaration is exited.

func (*BaseFqlParserListener) VisitErrorNode 

func (s *BaseFqlParserListener) VisitErrorNode(node antlr.ErrorNode)

VisitErrorNode is called when an error node is visited.

func (*BaseFqlParserListener) VisitTerminal 

func (s *BaseFqlParserListener) VisitTerminal(node antlr.TerminalNode)

VisitTerminal is called when a terminal node is visited.

type BaseFqlParserVisitor 

type BaseFqlParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseFqlParserVisitor) VisitArguments 

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

func (*BaseFqlParserVisitor) VisitArrayElementList 

func (v *BaseFqlParserVisitor) VisitArrayElementList(ctx *ArrayElementListContext) interface{}

func (*BaseFqlParserVisitor) VisitArrayLiteral 

func (v *BaseFqlParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitArrayOperator 

func (v *BaseFqlParserVisitor) VisitArrayOperator(ctx *ArrayOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitBody 

func (v *BaseFqlParserVisitor) VisitBody(ctx *BodyContext) interface{}

func (*BaseFqlParserVisitor) VisitBodyExpression 

func (v *BaseFqlParserVisitor) VisitBodyExpression(ctx *BodyExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitBodyStatement 

func (v *BaseFqlParserVisitor) VisitBodyStatement(ctx *BodyStatementContext) interface{}

func (*BaseFqlParserVisitor) VisitBooleanLiteral 

func (v *BaseFqlParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectAggregateExpression 

func (v *BaseFqlParserVisitor) VisitCollectAggregateExpression(ctx *CollectAggregateExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectAggregateVariable 

func (v *BaseFqlParserVisitor) VisitCollectAggregateVariable(ctx *CollectAggregateVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectClause 

func (v *BaseFqlParserVisitor) VisitCollectClause(ctx *CollectClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectCountVariable 

func (v *BaseFqlParserVisitor) VisitCollectCountVariable(ctx *CollectCountVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectGroupVariable 

func (v *BaseFqlParserVisitor) VisitCollectGroupVariable(ctx *CollectGroupVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectKeepVariable 

func (v *BaseFqlParserVisitor) VisitCollectKeepVariable(ctx *CollectKeepVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectOption 

func (v *BaseFqlParserVisitor) VisitCollectOption(ctx *CollectOptionContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectVariable 

func (v *BaseFqlParserVisitor) VisitCollectVariable(ctx *CollectVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitComputedPropertyName 

func (v *BaseFqlParserVisitor) VisitComputedPropertyName(ctx *ComputedPropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitEqualityOperator 

func (v *BaseFqlParserVisitor) VisitEqualityOperator(ctx *EqualityOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitExpression 

func (v *BaseFqlParserVisitor) VisitExpression(ctx *ExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitExpressionSequence 

func (v *BaseFqlParserVisitor) VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}

func (*BaseFqlParserVisitor) VisitFilterClause 

func (v *BaseFqlParserVisitor) VisitFilterClause(ctx *FilterClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitFloatLiteral 

func (v *BaseFqlParserVisitor) VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpression 

func (v *BaseFqlParserVisitor) VisitForExpression(ctx *ForExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionBody 

func (v *BaseFqlParserVisitor) VisitForExpressionBody(ctx *ForExpressionBodyContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionClause 

func (v *BaseFqlParserVisitor) VisitForExpressionClause(ctx *ForExpressionClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionKeyVariable 

func (v *BaseFqlParserVisitor) VisitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionReturn 

func (v *BaseFqlParserVisitor) VisitForExpressionReturn(ctx *ForExpressionReturnContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionSource 

func (v *BaseFqlParserVisitor) VisitForExpressionSource(ctx *ForExpressionSourceContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionValueVariable 

func (v *BaseFqlParserVisitor) VisitForExpressionValueVariable(ctx *ForExpressionValueVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitForTernaryExpression 

func (v *BaseFqlParserVisitor) VisitForTernaryExpression(ctx *ForTernaryExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitFunctionCallExpression 

func (v *BaseFqlParserVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitInOperator 

func (v *BaseFqlParserVisitor) VisitInOperator(ctx *InOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitIntegerLiteral 

func (v *BaseFqlParserVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitLimitClause 

func (v *BaseFqlParserVisitor) VisitLimitClause(ctx *LimitClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitLogicalOperator 

func (v *BaseFqlParserVisitor) VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitMathOperator 

func (v *BaseFqlParserVisitor) VisitMathOperator(ctx *MathOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitMemberExpression 

func (v *BaseFqlParserVisitor) VisitMemberExpression(ctx *MemberExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitNoneLiteral 

func (v *BaseFqlParserVisitor) VisitNoneLiteral(ctx *NoneLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitObjectLiteral 

func (v *BaseFqlParserVisitor) VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitParam 

func (v *BaseFqlParserVisitor) VisitParam(ctx *ParamContext) interface{}

func (*BaseFqlParserVisitor) VisitProgram 

func (v *BaseFqlParserVisitor) VisitProgram(ctx *ProgramContext) interface{}

func (*BaseFqlParserVisitor) VisitPropertyAssignment 

func (v *BaseFqlParserVisitor) VisitPropertyAssignment(ctx *PropertyAssignmentContext) interface{}

func (*BaseFqlParserVisitor) VisitPropertyName 

func (v *BaseFqlParserVisitor) VisitPropertyName(ctx *PropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitRangeOperator 

func (v *BaseFqlParserVisitor) VisitRangeOperator(ctx *RangeOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitReturnExpression 

func (v *BaseFqlParserVisitor) VisitReturnExpression(ctx *ReturnExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitShorthandPropertyName 

func (v *BaseFqlParserVisitor) VisitShorthandPropertyName(ctx *ShorthandPropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitSortClause 

func (v *BaseFqlParserVisitor) VisitSortClause(ctx *SortClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitSortClauseExpression 

func (v *BaseFqlParserVisitor) VisitSortClauseExpression(ctx *SortClauseExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitStringLiteral 

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

func (*BaseFqlParserVisitor) VisitUnaryOperator 

func (v *BaseFqlParserVisitor) VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitVariable 

func (v *BaseFqlParserVisitor) VisitVariable(ctx *VariableContext) interface{}

func (*BaseFqlParserVisitor) VisitVariableDeclaration 

func (v *BaseFqlParserVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

type BodyContext 

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

func NewBodyContext 

func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext

func NewEmptyBodyContext 

func NewEmptyBodyContext() *BodyContext

func (*BodyContext) Accept 

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

func (*BodyContext) AllBodyStatement 

func (s *BodyContext) AllBodyStatement() []IBodyStatementContext

func (*BodyContext) BodyExpression 

func (s *BodyContext) BodyExpression() IBodyExpressionContext

func (*BodyContext) BodyStatement 

func (s *BodyContext) BodyStatement(i int) IBodyStatementContext

func (*BodyContext) EnterRule 

func (s *BodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyContext) ExitRule 

func (s *BodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyContext) GetParser 

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

func (*BodyContext) GetRuleContext 

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

func (*BodyContext) IsBodyContext 

func (*BodyContext) IsBodyContext()

func (*BodyContext) ToStringTree 

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

type BodyExpressionContext 

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

func NewBodyExpressionContext 

func NewBodyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyExpressionContext

func NewEmptyBodyExpressionContext 

func NewEmptyBodyExpressionContext() *BodyExpressionContext

func (*BodyExpressionContext) Accept 

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

func (*BodyExpressionContext) EnterRule 

func (s *BodyExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyExpressionContext) ExitRule 

func (s *BodyExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyExpressionContext) ForExpression 

func (s *BodyExpressionContext) ForExpression() IForExpressionContext

func (*BodyExpressionContext) GetParser 

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

func (*BodyExpressionContext) GetRuleContext 

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

func (*BodyExpressionContext) IsBodyExpressionContext 

func (*BodyExpressionContext) IsBodyExpressionContext()

func (*BodyExpressionContext) ReturnExpression 

func (s *BodyExpressionContext) ReturnExpression() IReturnExpressionContext

func (*BodyExpressionContext) ToStringTree 

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

type BodyStatementContext 

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

func NewBodyStatementContext 

func NewBodyStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyStatementContext

func NewEmptyBodyStatementContext 

func NewEmptyBodyStatementContext() *BodyStatementContext

func (*BodyStatementContext) Accept 

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

func (*BodyStatementContext) EnterRule 

func (s *BodyStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyStatementContext) ExitRule 

func (s *BodyStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyStatementContext) FunctionCallExpression 

func (s *BodyStatementContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*BodyStatementContext) GetParser 

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

func (*BodyStatementContext) GetRuleContext 

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

func (*BodyStatementContext) IsBodyStatementContext 

func (*BodyStatementContext) IsBodyStatementContext()

func (*BodyStatementContext) ToStringTree 

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

func (*BodyStatementContext) VariableDeclaration 

func (s *BodyStatementContext) VariableDeclaration() IVariableDeclarationContext

type BooleanLiteralContext 

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

func NewBooleanLiteralContext 

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

func NewEmptyBooleanLiteralContext 

func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

func (*BooleanLiteralContext) Accept 

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

func (*BooleanLiteralContext) BooleanLiteral 

func (s *BooleanLiteralContext) BooleanLiteral() antlr.TerminalNode

func (*BooleanLiteralContext) EnterRule 

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

func (*BooleanLiteralContext) ExitRule 

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

func (*BooleanLiteralContext) GetParser 

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

func (*BooleanLiteralContext) GetRuleContext 

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

func (*BooleanLiteralContext) IsBooleanLiteralContext 

func (*BooleanLiteralContext) IsBooleanLiteralContext()

func (*BooleanLiteralContext) ToStringTree 

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

type CollectAggregateExpressionContext 

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

func NewCollectAggregateExpressionContext 

func NewCollectAggregateExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateExpressionContext

func NewEmptyCollectAggregateExpressionContext 

func NewEmptyCollectAggregateExpressionContext() *CollectAggregateExpressionContext

func (*CollectAggregateExpressionContext) Accept 

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

func (*CollectAggregateExpressionContext) EnterRule 

func (s *CollectAggregateExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectAggregateExpressionContext) ExitRule 

func (s *CollectAggregateExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectAggregateExpressionContext) Expression 

func (s *CollectAggregateExpressionContext) Expression() IExpressionContext

func (*CollectAggregateExpressionContext) GetParser 

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

func (*CollectAggregateExpressionContext) GetRuleContext 

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

func (*CollectAggregateExpressionContext) IsCollectAggregateExpressionContext 

func (*CollectAggregateExpressionContext) IsCollectAggregateExpressionContext()

func (*CollectAggregateExpressionContext) ToStringTree 

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

type CollectAggregateVariableContext 

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

func NewCollectAggregateVariableContext 

func NewCollectAggregateVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateVariableContext

func NewEmptyCollectAggregateVariableContext 

func NewEmptyCollectAggregateVariableContext() *CollectAggregateVariableContext

func (*CollectAggregateVariableContext) Accept 

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

func (*CollectAggregateVariableContext) EnterRule 

func (s *CollectAggregateVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectAggregateVariableContext) ExitRule 

func (s *CollectAggregateVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectAggregateVariableContext) GetParser 

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

func (*CollectAggregateVariableContext) GetRuleContext 

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

func (*CollectAggregateVariableContext) Identifier 

func (s *CollectAggregateVariableContext) Identifier() antlr.TerminalNode

func (*CollectAggregateVariableContext) IsCollectAggregateVariableContext 

func (*CollectAggregateVariableContext) IsCollectAggregateVariableContext()

func (*CollectAggregateVariableContext) ToStringTree 

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

type CollectClauseContext 

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

func NewCollectClauseContext 

func NewCollectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectClauseContext

func NewEmptyCollectClauseContext 

func NewEmptyCollectClauseContext() *CollectClauseContext

func (*CollectClauseContext) Accept 

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

func (*CollectClauseContext) Aggregate 

func (s *CollectClauseContext) Aggregate() antlr.TerminalNode

func (*CollectClauseContext) AllAssign 

func (s *CollectClauseContext) AllAssign() []antlr.TerminalNode

func (*CollectClauseContext) Assign 

func (s *CollectClauseContext) Assign(i int) antlr.TerminalNode

func (*CollectClauseContext) Collect 

func (s *CollectClauseContext) Collect() antlr.TerminalNode

func (*CollectClauseContext) CollectAggregateExpression 

func (s *CollectClauseContext) CollectAggregateExpression() ICollectAggregateExpressionContext

func (*CollectClauseContext) CollectAggregateVariable 

func (s *CollectClauseContext) CollectAggregateVariable() ICollectAggregateVariableContext

func (*CollectClauseContext) CollectCountVariable 

func (s *CollectClauseContext) CollectCountVariable() ICollectCountVariableContext

func (*CollectClauseContext) CollectGroupVariable 

func (s *CollectClauseContext) CollectGroupVariable() ICollectGroupVariableContext

func (*CollectClauseContext) CollectKeepVariable 

func (s *CollectClauseContext) CollectKeepVariable() ICollectKeepVariableContext

func (*CollectClauseContext) CollectVariable 

func (s *CollectClauseContext) CollectVariable() ICollectVariableContext

func (*CollectClauseContext) Count 

func (s *CollectClauseContext) Count() antlr.TerminalNode

func (*CollectClauseContext) EnterRule 

func (s *CollectClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectClauseContext) ExitRule 

func (s *CollectClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectClauseContext) Expression 

func (s *CollectClauseContext) Expression() IExpressionContext

func (*CollectClauseContext) GetParser 

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

func (*CollectClauseContext) GetRuleContext 

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

func (*CollectClauseContext) Into 

func (s *CollectClauseContext) Into() antlr.TerminalNode

func (*CollectClauseContext) IsCollectClauseContext 

func (*CollectClauseContext) IsCollectClauseContext()

func (*CollectClauseContext) Keep 

func (s *CollectClauseContext) Keep() antlr.TerminalNode

func (*CollectClauseContext) ToStringTree 

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

func (*CollectClauseContext) With 

func (s *CollectClauseContext) With() antlr.TerminalNode

type CollectCountVariableContext 

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

func NewCollectCountVariableContext 

func NewCollectCountVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectCountVariableContext

func NewEmptyCollectCountVariableContext 

func NewEmptyCollectCountVariableContext() *CollectCountVariableContext

func (*CollectCountVariableContext) Accept 

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

func (*CollectCountVariableContext) EnterRule 

func (s *CollectCountVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectCountVariableContext) ExitRule 

func (s *CollectCountVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectCountVariableContext) GetParser 

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

func (*CollectCountVariableContext) GetRuleContext 

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

func (*CollectCountVariableContext) Identifier 

func (s *CollectCountVariableContext) Identifier() antlr.TerminalNode

func (*CollectCountVariableContext) IsCollectCountVariableContext 

func (*CollectCountVariableContext) IsCollectCountVariableContext()

func (*CollectCountVariableContext) ToStringTree 

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

type CollectGroupVariableContext 

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

func NewCollectGroupVariableContext 

func NewCollectGroupVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupVariableContext

func NewEmptyCollectGroupVariableContext 

func NewEmptyCollectGroupVariableContext() *CollectGroupVariableContext

func (*CollectGroupVariableContext) Accept 

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

func (*CollectGroupVariableContext) EnterRule 

func (s *CollectGroupVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectGroupVariableContext) ExitRule 

func (s *CollectGroupVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectGroupVariableContext) GetParser 

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

func (*CollectGroupVariableContext) GetRuleContext 

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

func (*CollectGroupVariableContext) Identifier 

func (s *CollectGroupVariableContext) Identifier() antlr.TerminalNode

func (*CollectGroupVariableContext) IsCollectGroupVariableContext 

func (*CollectGroupVariableContext) IsCollectGroupVariableContext()

func (*CollectGroupVariableContext) ToStringTree 

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

type CollectKeepVariableContext 

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

func NewCollectKeepVariableContext 

func NewCollectKeepVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectKeepVariableContext

func NewEmptyCollectKeepVariableContext 

func NewEmptyCollectKeepVariableContext() *CollectKeepVariableContext

func (*CollectKeepVariableContext) Accept 

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

func (*CollectKeepVariableContext) EnterRule 

func (s *CollectKeepVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectKeepVariableContext) ExitRule 

func (s *CollectKeepVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectKeepVariableContext) GetParser 

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

func (*CollectKeepVariableContext) GetRuleContext 

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

func (*CollectKeepVariableContext) Identifier 

func (s *CollectKeepVariableContext) Identifier() antlr.TerminalNode

func (*CollectKeepVariableContext) IsCollectKeepVariableContext 

func (*CollectKeepVariableContext) IsCollectKeepVariableContext()

func (*CollectKeepVariableContext) ToStringTree 

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

type CollectOptionContext 

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

func NewCollectOptionContext 

func NewCollectOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectOptionContext

func NewEmptyCollectOptionContext 

func NewEmptyCollectOptionContext() *CollectOptionContext

func (*CollectOptionContext) Accept 

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

func (*CollectOptionContext) EnterRule 

func (s *CollectOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectOptionContext) ExitRule 

func (s *CollectOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectOptionContext) GetParser 

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

func (*CollectOptionContext) GetRuleContext 

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

func (*CollectOptionContext) IsCollectOptionContext 

func (*CollectOptionContext) IsCollectOptionContext()

func (*CollectOptionContext) ToStringTree 

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

type CollectVariableContext 

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

func NewCollectVariableContext 

func NewCollectVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectVariableContext

func NewEmptyCollectVariableContext 

func NewEmptyCollectVariableContext() *CollectVariableContext

func (*CollectVariableContext) Accept 

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

func (*CollectVariableContext) EnterRule 

func (s *CollectVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectVariableContext) ExitRule 

func (s *CollectVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectVariableContext) GetParser 

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

func (*CollectVariableContext) GetRuleContext 

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

func (*CollectVariableContext) Identifier 

func (s *CollectVariableContext) Identifier() antlr.TerminalNode

func (*CollectVariableContext) IsCollectVariableContext 

func (*CollectVariableContext) IsCollectVariableContext()

func (*CollectVariableContext) ToStringTree 

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

type ComputedPropertyNameContext 

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

func NewComputedPropertyNameContext 

func NewComputedPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComputedPropertyNameContext

func NewEmptyComputedPropertyNameContext 

func NewEmptyComputedPropertyNameContext() *ComputedPropertyNameContext

func (*ComputedPropertyNameContext) Accept 

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

func (*ComputedPropertyNameContext) CloseBracket 

func (s *ComputedPropertyNameContext) CloseBracket() antlr.TerminalNode

func (*ComputedPropertyNameContext) EnterRule 

func (s *ComputedPropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*ComputedPropertyNameContext) ExitRule 

func (s *ComputedPropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*ComputedPropertyNameContext) Expression 

func (s *ComputedPropertyNameContext) Expression() IExpressionContext

func (*ComputedPropertyNameContext) GetParser 

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

func (*ComputedPropertyNameContext) GetRuleContext 

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

func (*ComputedPropertyNameContext) IsComputedPropertyNameContext 

func (*ComputedPropertyNameContext) IsComputedPropertyNameContext()

func (*ComputedPropertyNameContext) OpenBracket 

func (s *ComputedPropertyNameContext) OpenBracket() antlr.TerminalNode

func (*ComputedPropertyNameContext) ToStringTree 

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

type EqualityOperatorContext 

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

func NewEmptyEqualityOperatorContext 

func NewEmptyEqualityOperatorContext() *EqualityOperatorContext

func NewEqualityOperatorContext 

func NewEqualityOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityOperatorContext

func (*EqualityOperatorContext) Accept 

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

func (*EqualityOperatorContext) EnterRule 

func (s *EqualityOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*EqualityOperatorContext) Eq 

func (s *EqualityOperatorContext) Eq() antlr.TerminalNode

func (*EqualityOperatorContext) ExitRule 

func (s *EqualityOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*EqualityOperatorContext) GetParser 

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

func (*EqualityOperatorContext) GetRuleContext 

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

func (*EqualityOperatorContext) Gt 

func (s *EqualityOperatorContext) Gt() antlr.TerminalNode

func (*EqualityOperatorContext) Gte 

func (s *EqualityOperatorContext) Gte() antlr.TerminalNode

func (*EqualityOperatorContext) IsEqualityOperatorContext 

func (*EqualityOperatorContext) IsEqualityOperatorContext()

func (*EqualityOperatorContext) Lt 

func (s *EqualityOperatorContext) Lt() antlr.TerminalNode

func (*EqualityOperatorContext) Lte 

func (s *EqualityOperatorContext) Lte() antlr.TerminalNode

func (*EqualityOperatorContext) Neq 

func (s *EqualityOperatorContext) Neq() antlr.TerminalNode

func (*EqualityOperatorContext) ToStringTree 

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

type ExpressionContext 

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

func NewEmptyExpressionContext 

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext 

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

func (*ExpressionContext) Accept 

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

func (*ExpressionContext) AllExpression 

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

func (*ExpressionContext) ArrayLiteral 

func (s *ExpressionContext) ArrayLiteral() IArrayLiteralContext

func (*ExpressionContext) ArrayOperator 

func (s *ExpressionContext) ArrayOperator() IArrayOperatorContext

func (*ExpressionContext) BooleanLiteral 

func (s *ExpressionContext) BooleanLiteral() IBooleanLiteralContext

func (*ExpressionContext) CloseParen 

func (s *ExpressionContext) CloseParen() antlr.TerminalNode

func (*ExpressionContext) Colon 

func (s *ExpressionContext) Colon() antlr.TerminalNode

func (*ExpressionContext) EnterRule 

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

func (*ExpressionContext) EqualityOperator 

func (s *ExpressionContext) EqualityOperator() IEqualityOperatorContext

func (*ExpressionContext) ExitRule 

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

func (*ExpressionContext) Expression 

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

func (*ExpressionContext) ExpressionSequence 

func (s *ExpressionContext) ExpressionSequence() IExpressionSequenceContext

func (*ExpressionContext) FloatLiteral 

func (s *ExpressionContext) FloatLiteral() IFloatLiteralContext

func (*ExpressionContext) FunctionCallExpression 

func (s *ExpressionContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ExpressionContext) GetParser 

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

func (*ExpressionContext) GetRuleContext 

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

func (*ExpressionContext) InOperator 

func (s *ExpressionContext) InOperator() IInOperatorContext

func (*ExpressionContext) IntegerLiteral 

func (s *ExpressionContext) IntegerLiteral() IIntegerLiteralContext

func (*ExpressionContext) IsExpressionContext 

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) LogicalOperator 

func (s *ExpressionContext) LogicalOperator() ILogicalOperatorContext

func (*ExpressionContext) MathOperator 

func (s *ExpressionContext) MathOperator() IMathOperatorContext

func (*ExpressionContext) MemberExpression 

func (s *ExpressionContext) MemberExpression() IMemberExpressionContext

func (*ExpressionContext) Minus 

func (s *ExpressionContext) Minus() antlr.TerminalNode

func (*ExpressionContext) NoneLiteral 

func (s *ExpressionContext) NoneLiteral() INoneLiteralContext

func (*ExpressionContext) Not 

func (s *ExpressionContext) Not() antlr.TerminalNode

func (*ExpressionContext) ObjectLiteral 

func (s *ExpressionContext) ObjectLiteral() IObjectLiteralContext

func (*ExpressionContext) OpenParen 

func (s *ExpressionContext) OpenParen() antlr.TerminalNode

func (*ExpressionContext) Param 

func (s *ExpressionContext) Param() IParamContext

func (*ExpressionContext) Plus 

func (s *ExpressionContext) Plus() antlr.TerminalNode

func (*ExpressionContext) QuestionMark 

func (s *ExpressionContext) QuestionMark() antlr.TerminalNode

func (*ExpressionContext) RangeOperator 

func (s *ExpressionContext) RangeOperator() IRangeOperatorContext

func (*ExpressionContext) StringLiteral 

func (s *ExpressionContext) StringLiteral() IStringLiteralContext

func (*ExpressionContext) ToStringTree 

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

func (*ExpressionContext) Variable 

func (s *ExpressionContext) Variable() IVariableContext

type ExpressionSequenceContext 

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

func NewEmptyExpressionSequenceContext 

func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext

func NewExpressionSequenceContext 

func NewExpressionSequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSequenceContext

func (*ExpressionSequenceContext) Accept 

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

func (*ExpressionSequenceContext) AllComma 

func (s *ExpressionSequenceContext) AllComma() []antlr.TerminalNode

func (*ExpressionSequenceContext) AllExpression 

func (s *ExpressionSequenceContext) AllExpression() []IExpressionContext

func (*ExpressionSequenceContext) Comma 

func (s *ExpressionSequenceContext) Comma(i int) antlr.TerminalNode

func (*ExpressionSequenceContext) EnterRule 

func (s *ExpressionSequenceContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionSequenceContext) ExitRule 

func (s *ExpressionSequenceContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionSequenceContext) Expression 

func (s *ExpressionSequenceContext) Expression(i int) IExpressionContext

func (*ExpressionSequenceContext) GetParser 

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

func (*ExpressionSequenceContext) GetRuleContext 

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

func (*ExpressionSequenceContext) IsExpressionSequenceContext 

func (*ExpressionSequenceContext) IsExpressionSequenceContext()

func (*ExpressionSequenceContext) ToStringTree 

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

type FilterClauseContext 

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

func NewEmptyFilterClauseContext 

func NewEmptyFilterClauseContext() *FilterClauseContext

func NewFilterClauseContext 

func NewFilterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterClauseContext

func (*FilterClauseContext) Accept 

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

func (*FilterClauseContext) EnterRule 

func (s *FilterClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*FilterClauseContext) ExitRule 

func (s *FilterClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*FilterClauseContext) Expression 

func (s *FilterClauseContext) Expression() IExpressionContext

func (*FilterClauseContext) Filter 

func (s *FilterClauseContext) Filter() antlr.TerminalNode

func (*FilterClauseContext) GetParser 

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

func (*FilterClauseContext) GetRuleContext 

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

func (*FilterClauseContext) IsFilterClauseContext 

func (*FilterClauseContext) IsFilterClauseContext()

func (*FilterClauseContext) ToStringTree 

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

type FloatLiteralContext 

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

func NewEmptyFloatLiteralContext 

func NewEmptyFloatLiteralContext() *FloatLiteralContext

func NewFloatLiteralContext 

func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext

func (*FloatLiteralContext) Accept 

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

func (*FloatLiteralContext) EnterRule 

func (s *FloatLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*FloatLiteralContext) ExitRule 

func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*FloatLiteralContext) FloatLiteral 

func (s *FloatLiteralContext) FloatLiteral() antlr.TerminalNode

func (*FloatLiteralContext) GetParser 

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

func (*FloatLiteralContext) GetRuleContext 

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

func (*FloatLiteralContext) IsFloatLiteralContext 

func (*FloatLiteralContext) IsFloatLiteralContext()

func (*FloatLiteralContext) ToStringTree 

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

type ForExpressionBodyContext 

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

func NewEmptyForExpressionBodyContext 

func NewEmptyForExpressionBodyContext() *ForExpressionBodyContext

func NewForExpressionBodyContext 

func NewForExpressionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionBodyContext

func (*ForExpressionBodyContext) Accept 

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

func (*ForExpressionBodyContext) EnterRule 

func (s *ForExpressionBodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionBodyContext) ExitRule 

func (s *ForExpressionBodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionBodyContext) FunctionCallExpression 

func (s *ForExpressionBodyContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ForExpressionBodyContext) GetParser 

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

func (*ForExpressionBodyContext) GetRuleContext 

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

func (*ForExpressionBodyContext) IsForExpressionBodyContext 

func (*ForExpressionBodyContext) IsForExpressionBodyContext()

func (*ForExpressionBodyContext) ToStringTree 

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

func (*ForExpressionBodyContext) VariableDeclaration 

func (s *ForExpressionBodyContext) VariableDeclaration() IVariableDeclarationContext

type ForExpressionClauseContext 

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

func NewEmptyForExpressionClauseContext 

func NewEmptyForExpressionClauseContext() *ForExpressionClauseContext

func NewForExpressionClauseContext 

func NewForExpressionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionClauseContext

func (*ForExpressionClauseContext) Accept 

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

func (*ForExpressionClauseContext) CollectClause 

func (s *ForExpressionClauseContext) CollectClause() ICollectClauseContext

func (*ForExpressionClauseContext) EnterRule 

func (s *ForExpressionClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionClauseContext) ExitRule 

func (s *ForExpressionClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionClauseContext) FilterClause 

func (s *ForExpressionClauseContext) FilterClause() IFilterClauseContext

func (*ForExpressionClauseContext) GetParser 

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

func (*ForExpressionClauseContext) GetRuleContext 

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

func (*ForExpressionClauseContext) IsForExpressionClauseContext 

func (*ForExpressionClauseContext) IsForExpressionClauseContext()

func (*ForExpressionClauseContext) LimitClause 

func (s *ForExpressionClauseContext) LimitClause() ILimitClauseContext

func (*ForExpressionClauseContext) SortClause 

func (s *ForExpressionClauseContext) SortClause() ISortClauseContext

func (*ForExpressionClauseContext) ToStringTree 

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

type ForExpressionContext 

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

func NewEmptyForExpressionContext 

func NewEmptyForExpressionContext() *ForExpressionContext

func NewForExpressionContext 

func NewForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionContext

func (*ForExpressionContext) Accept 

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

func (*ForExpressionContext) AllForExpressionBody 

func (s *ForExpressionContext) AllForExpressionBody() []IForExpressionBodyContext

func (*ForExpressionContext) AllForExpressionClause 

func (s *ForExpressionContext) AllForExpressionClause() []IForExpressionClauseContext

func (*ForExpressionContext) Comma 

func (s *ForExpressionContext) Comma() antlr.TerminalNode

func (*ForExpressionContext) EnterRule 

func (s *ForExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionContext) ExitRule 

func (s *ForExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionContext) For 

func (s *ForExpressionContext) For() antlr.TerminalNode

func (*ForExpressionContext) ForExpressionBody 

func (s *ForExpressionContext) ForExpressionBody(i int) IForExpressionBodyContext

func (*ForExpressionContext) ForExpressionClause 

func (s *ForExpressionContext) ForExpressionClause(i int) IForExpressionClauseContext

func (*ForExpressionContext) ForExpressionKeyVariable 

func (s *ForExpressionContext) ForExpressionKeyVariable() IForExpressionKeyVariableContext

func (*ForExpressionContext) ForExpressionReturn 

func (s *ForExpressionContext) ForExpressionReturn() IForExpressionReturnContext

func (*ForExpressionContext) ForExpressionSource 

func (s *ForExpressionContext) ForExpressionSource() IForExpressionSourceContext

func (*ForExpressionContext) ForExpressionValueVariable 

func (s *ForExpressionContext) ForExpressionValueVariable() IForExpressionValueVariableContext

func (*ForExpressionContext) GetParser 

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

func (*ForExpressionContext) GetRuleContext 

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

func (*ForExpressionContext) In 

func (s *ForExpressionContext) In() antlr.TerminalNode

func (*ForExpressionContext) IsForExpressionContext 

func (*ForExpressionContext) IsForExpressionContext()

func (*ForExpressionContext) ToStringTree 

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

type ForExpressionKeyVariableContext 

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

func NewEmptyForExpressionKeyVariableContext 

func NewEmptyForExpressionKeyVariableContext() *ForExpressionKeyVariableContext

func NewForExpressionKeyVariableContext 

func NewForExpressionKeyVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionKeyVariableContext

func (*ForExpressionKeyVariableContext) Accept 

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

func (*ForExpressionKeyVariableContext) EnterRule 

func (s *ForExpressionKeyVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionKeyVariableContext) ExitRule 

func (s *ForExpressionKeyVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionKeyVariableContext) GetParser 

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

func (*ForExpressionKeyVariableContext) GetRuleContext 

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

func (*ForExpressionKeyVariableContext) Identifier 

func (s *ForExpressionKeyVariableContext) Identifier() antlr.TerminalNode

func (*ForExpressionKeyVariableContext) IsForExpressionKeyVariableContext 

func (*ForExpressionKeyVariableContext) IsForExpressionKeyVariableContext()

func (*ForExpressionKeyVariableContext) ToStringTree 

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

type ForExpressionReturnContext 

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

func NewEmptyForExpressionReturnContext 

func NewEmptyForExpressionReturnContext() *ForExpressionReturnContext

func NewForExpressionReturnContext 

func NewForExpressionReturnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionReturnContext

func (*ForExpressionReturnContext) Accept 

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

func (*ForExpressionReturnContext) EnterRule 

func (s *ForExpressionReturnContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionReturnContext) ExitRule 

func (s *ForExpressionReturnContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionReturnContext) ForExpression 

func (s *ForExpressionReturnContext) ForExpression() IForExpressionContext

func (*ForExpressionReturnContext) GetParser 

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

func (*ForExpressionReturnContext) GetRuleContext 

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

func (*ForExpressionReturnContext) IsForExpressionReturnContext 

func (*ForExpressionReturnContext) IsForExpressionReturnContext()

func (*ForExpressionReturnContext) ReturnExpression 

func (s *ForExpressionReturnContext) ReturnExpression() IReturnExpressionContext

func (*ForExpressionReturnContext) ToStringTree 

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

type ForExpressionSourceContext 

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

func NewEmptyForExpressionSourceContext 

func NewEmptyForExpressionSourceContext() *ForExpressionSourceContext

func NewForExpressionSourceContext 

func NewForExpressionSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionSourceContext

func (*ForExpressionSourceContext) Accept 

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

func (*ForExpressionSourceContext) ArrayLiteral 

func (s *ForExpressionSourceContext) ArrayLiteral() IArrayLiteralContext

func (*ForExpressionSourceContext) EnterRule 

func (s *ForExpressionSourceContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionSourceContext) ExitRule 

func (s *ForExpressionSourceContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionSourceContext) FunctionCallExpression 

func (s *ForExpressionSourceContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ForExpressionSourceContext) GetParser 

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

func (*ForExpressionSourceContext) GetRuleContext 

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

func (*ForExpressionSourceContext) IsForExpressionSourceContext 

func (*ForExpressionSourceContext) IsForExpressionSourceContext()

func (*ForExpressionSourceContext) MemberExpression 

func (s *ForExpressionSourceContext) MemberExpression() IMemberExpressionContext

func (*ForExpressionSourceContext) ObjectLiteral 

func (s *ForExpressionSourceContext) ObjectLiteral() IObjectLiteralContext

func (*ForExpressionSourceContext) Param 

func (s *ForExpressionSourceContext) Param() IParamContext

func (*ForExpressionSourceContext) RangeOperator 

func (s *ForExpressionSourceContext) RangeOperator() IRangeOperatorContext

func (*ForExpressionSourceContext) ToStringTree 

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

func (*ForExpressionSourceContext) Variable 

func (s *ForExpressionSourceContext) Variable() IVariableContext

type ForExpressionValueVariableContext 

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

func NewEmptyForExpressionValueVariableContext 

func NewEmptyForExpressionValueVariableContext() *ForExpressionValueVariableContext

func NewForExpressionValueVariableContext 

func NewForExpressionValueVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionValueVariableContext

func (*ForExpressionValueVariableContext) Accept 

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

func (*ForExpressionValueVariableContext) EnterRule 

func (s *ForExpressionValueVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionValueVariableContext) ExitRule 

func (s *ForExpressionValueVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionValueVariableContext) GetParser 

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

func (*ForExpressionValueVariableContext) GetRuleContext 

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

func (*ForExpressionValueVariableContext) Identifier 

func (s *ForExpressionValueVariableContext) Identifier() antlr.TerminalNode

func (*ForExpressionValueVariableContext) IsForExpressionValueVariableContext 

func (*ForExpressionValueVariableContext) IsForExpressionValueVariableContext()

func (*ForExpressionValueVariableContext) ToStringTree 

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

type ForTernaryExpressionContext 

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

func NewEmptyForTernaryExpressionContext 

func NewEmptyForTernaryExpressionContext() *ForTernaryExpressionContext

func NewForTernaryExpressionContext 

func NewForTernaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForTernaryExpressionContext

func (*ForTernaryExpressionContext) Accept 

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

func (*ForTernaryExpressionContext) AllCloseParen 

func (s *ForTernaryExpressionContext) AllCloseParen() []antlr.TerminalNode

func (*ForTernaryExpressionContext) AllExpression 

func (s *ForTernaryExpressionContext) AllExpression() []IExpressionContext

func (*ForTernaryExpressionContext) AllForExpression 

func (s *ForTernaryExpressionContext) AllForExpression() []IForExpressionContext

func (*ForTernaryExpressionContext) AllOpenParen 

func (s *ForTernaryExpressionContext) AllOpenParen() []antlr.TerminalNode

func (*ForTernaryExpressionContext) CloseParen 

func (s *ForTernaryExpressionContext) CloseParen(i int) antlr.TerminalNode

func (*ForTernaryExpressionContext) Colon 

func (s *ForTernaryExpressionContext) Colon() antlr.TerminalNode

func (*ForTernaryExpressionContext) EnterRule 

func (s *ForTernaryExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForTernaryExpressionContext) ExitRule 

func (s *ForTernaryExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForTernaryExpressionContext) Expression 

func (s *ForTernaryExpressionContext) Expression(i int) IExpressionContext

func (*ForTernaryExpressionContext) ForExpression 

func (s *ForTernaryExpressionContext) ForExpression(i int) IForExpressionContext

func (*ForTernaryExpressionContext) GetParser 

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

func (*ForTernaryExpressionContext) GetRuleContext 

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

func (*ForTernaryExpressionContext) IsForTernaryExpressionContext 

func (*ForTernaryExpressionContext) IsForTernaryExpressionContext()

func (*ForTernaryExpressionContext) OpenParen 

func (s *ForTernaryExpressionContext) OpenParen(i int) antlr.TerminalNode

func (*ForTernaryExpressionContext) QuestionMark 

func (s *ForTernaryExpressionContext) QuestionMark() antlr.TerminalNode

func (*ForTernaryExpressionContext) ToStringTree 

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

type FqlLexer 

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

func NewFqlLexer 

func NewFqlLexer(input antlr.CharStream) *FqlLexer

type FqlParser 

type FqlParser struct {
	*antlr.BaseParser
}

func NewFqlParser 

func NewFqlParser(input antlr.TokenStream) *FqlParser

func (*FqlParser) Arguments 

func (p *FqlParser) Arguments() (localctx IArgumentsContext)

func (*FqlParser) ArrayElementList 

func (p *FqlParser) ArrayElementList() (localctx IArrayElementListContext)

func (*FqlParser) ArrayLiteral 

func (p *FqlParser) ArrayLiteral() (localctx IArrayLiteralContext)

func (*FqlParser) ArrayOperator 

func (p *FqlParser) ArrayOperator() (localctx IArrayOperatorContext)

func (*FqlParser) Body 

func (p *FqlParser) Body() (localctx IBodyContext)

func (*FqlParser) BodyExpression 

func (p *FqlParser) BodyExpression() (localctx IBodyExpressionContext)

func (*FqlParser) BodyStatement 

func (p *FqlParser) BodyStatement() (localctx IBodyStatementContext)

func (*FqlParser) BooleanLiteral 

func (p *FqlParser) BooleanLiteral() (localctx IBooleanLiteralContext)

func (*FqlParser) CollectAggregateExpression 

func (p *FqlParser) CollectAggregateExpression() (localctx ICollectAggregateExpressionContext)

func (*FqlParser) CollectAggregateVariable 

func (p *FqlParser) CollectAggregateVariable() (localctx ICollectAggregateVariableContext)

func (*FqlParser) CollectClause 

func (p *FqlParser) CollectClause() (localctx ICollectClauseContext)

func (*FqlParser) CollectCountVariable 

func (p *FqlParser) CollectCountVariable() (localctx ICollectCountVariableContext)

func (*FqlParser) CollectGroupVariable 

func (p *FqlParser) CollectGroupVariable() (localctx ICollectGroupVariableContext)

func (*FqlParser) CollectKeepVariable 

func (p *FqlParser) CollectKeepVariable() (localctx ICollectKeepVariableContext)

func (*FqlParser) CollectOption 

func (p *FqlParser) CollectOption() (localctx ICollectOptionContext)

func (*FqlParser) CollectVariable 

func (p *FqlParser) CollectVariable() (localctx ICollectVariableContext)

func (*FqlParser) ComputedPropertyName 

func (p *FqlParser) ComputedPropertyName() (localctx IComputedPropertyNameContext)

func (*FqlParser) EqualityOperator 

func (p *FqlParser) EqualityOperator() (localctx IEqualityOperatorContext)

func (*FqlParser) Expression 

func (p *FqlParser) Expression() (localctx IExpressionContext)

func (*FqlParser) ExpressionSequence 

func (p *FqlParser) ExpressionSequence() (localctx IExpressionSequenceContext)

func (*FqlParser) Expression_Sempred 

func (p *FqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*FqlParser) FilterClause 

func (p *FqlParser) FilterClause() (localctx IFilterClauseContext)

func (*FqlParser) FloatLiteral 

func (p *FqlParser) FloatLiteral() (localctx IFloatLiteralContext)

func (*FqlParser) ForExpression 

func (p *FqlParser) ForExpression() (localctx IForExpressionContext)

func (*FqlParser) ForExpressionBody 

func (p *FqlParser) ForExpressionBody() (localctx IForExpressionBodyContext)

func (*FqlParser) ForExpressionClause 

func (p *FqlParser) ForExpressionClause() (localctx IForExpressionClauseContext)

func (*FqlParser) ForExpressionKeyVariable 

func (p *FqlParser) ForExpressionKeyVariable() (localctx IForExpressionKeyVariableContext)

func (*FqlParser) ForExpressionReturn 

func (p *FqlParser) ForExpressionReturn() (localctx IForExpressionReturnContext)

func (*FqlParser) ForExpressionSource 

func (p *FqlParser) ForExpressionSource() (localctx IForExpressionSourceContext)

func (*FqlParser) ForExpressionValueVariable 

func (p *FqlParser) ForExpressionValueVariable() (localctx IForExpressionValueVariableContext)

func (*FqlParser) ForTernaryExpression 

func (p *FqlParser) ForTernaryExpression() (localctx IForTernaryExpressionContext)

func (*FqlParser) FunctionCallExpression 

func (p *FqlParser) FunctionCallExpression() (localctx IFunctionCallExpressionContext)

func (*FqlParser) InOperator 

func (p *FqlParser) InOperator() (localctx IInOperatorContext)

func (*FqlParser) IntegerLiteral 

func (p *FqlParser) IntegerLiteral() (localctx IIntegerLiteralContext)

func (*FqlParser) LimitClause 

func (p *FqlParser) LimitClause() (localctx ILimitClauseContext)

func (*FqlParser) LogicalOperator 

func (p *FqlParser) LogicalOperator() (localctx ILogicalOperatorContext)

func (*FqlParser) MathOperator 

func (p *FqlParser) MathOperator() (localctx IMathOperatorContext)

func (*FqlParser) MemberExpression 

func (p *FqlParser) MemberExpression() (localctx IMemberExpressionContext)

func (*FqlParser) NoneLiteral 

func (p *FqlParser) NoneLiteral() (localctx INoneLiteralContext)

func (*FqlParser) ObjectLiteral 

func (p *FqlParser) ObjectLiteral() (localctx IObjectLiteralContext)

func (*FqlParser) Param 

func (p *FqlParser) Param() (localctx IParamContext)

func (*FqlParser) Program 

func (p *FqlParser) Program() (localctx IProgramContext)

func (*FqlParser) PropertyAssignment 

func (p *FqlParser) PropertyAssignment() (localctx IPropertyAssignmentContext)

func (*FqlParser) PropertyName 

func (p *FqlParser) PropertyName() (localctx IPropertyNameContext)

func (*FqlParser) RangeOperator 

func (p *FqlParser) RangeOperator() (localctx IRangeOperatorContext)

func (*FqlParser) ReturnExpression 

func (p *FqlParser) ReturnExpression() (localctx IReturnExpressionContext)

func (*FqlParser) Sempred 

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

func (*FqlParser) ShorthandPropertyName 

func (p *FqlParser) ShorthandPropertyName() (localctx IShorthandPropertyNameContext)

func (*FqlParser) SortClause 

func (p *FqlParser) SortClause() (localctx ISortClauseContext)

func (*FqlParser) SortClauseExpression 

func (p *FqlParser) SortClauseExpression() (localctx ISortClauseExpressionContext)

func (*FqlParser) StringLiteral 

func (p *FqlParser) StringLiteral() (localctx IStringLiteralContext)

func (*FqlParser) UnaryOperator 

func (p *FqlParser) UnaryOperator() (localctx IUnaryOperatorContext)

func (*FqlParser) Variable 

func (p *FqlParser) Variable() (localctx IVariableContext)

func (*FqlParser) VariableDeclaration 

func (p *FqlParser) VariableDeclaration() (localctx IVariableDeclarationContext)

type FqlParserListener 

type FqlParserListener interface {
	antlr.ParseTreeListener

	// EnterProgram is called when entering the program production.
	EnterProgram(c *ProgramContext)

	// EnterBody is called when entering the body production.
	EnterBody(c *BodyContext)

	// EnterBodyStatement is called when entering the bodyStatement production.
	EnterBodyStatement(c *BodyStatementContext)

	// EnterBodyExpression is called when entering the bodyExpression production.
	EnterBodyExpression(c *BodyExpressionContext)

	// EnterReturnExpression is called when entering the returnExpression production.
	EnterReturnExpression(c *ReturnExpressionContext)

	// EnterForExpression is called when entering the forExpression production.
	EnterForExpression(c *ForExpressionContext)

	// EnterForExpressionValueVariable is called when entering the forExpressionValueVariable production.
	EnterForExpressionValueVariable(c *ForExpressionValueVariableContext)

	// EnterForExpressionKeyVariable is called when entering the forExpressionKeyVariable production.
	EnterForExpressionKeyVariable(c *ForExpressionKeyVariableContext)

	// EnterForExpressionSource is called when entering the forExpressionSource production.
	EnterForExpressionSource(c *ForExpressionSourceContext)

	// EnterForExpressionClause is called when entering the forExpressionClause production.
	EnterForExpressionClause(c *ForExpressionClauseContext)

	// EnterFilterClause is called when entering the filterClause production.
	EnterFilterClause(c *FilterClauseContext)

	// EnterLimitClause is called when entering the limitClause production.
	EnterLimitClause(c *LimitClauseContext)

	// EnterSortClause is called when entering the sortClause production.
	EnterSortClause(c *SortClauseContext)

	// EnterSortClauseExpression is called when entering the sortClauseExpression production.
	EnterSortClauseExpression(c *SortClauseExpressionContext)

	// EnterCollectClause is called when entering the collectClause production.
	EnterCollectClause(c *CollectClauseContext)

	// EnterCollectVariable is called when entering the collectVariable production.
	EnterCollectVariable(c *CollectVariableContext)

	// EnterCollectGroupVariable is called when entering the collectGroupVariable production.
	EnterCollectGroupVariable(c *CollectGroupVariableContext)

	// EnterCollectKeepVariable is called when entering the collectKeepVariable production.
	EnterCollectKeepVariable(c *CollectKeepVariableContext)

	// EnterCollectCountVariable is called when entering the collectCountVariable production.
	EnterCollectCountVariable(c *CollectCountVariableContext)

	// EnterCollectAggregateVariable is called when entering the collectAggregateVariable production.
	EnterCollectAggregateVariable(c *CollectAggregateVariableContext)

	// EnterCollectAggregateExpression is called when entering the collectAggregateExpression production.
	EnterCollectAggregateExpression(c *CollectAggregateExpressionContext)

	// EnterCollectOption is called when entering the collectOption production.
	EnterCollectOption(c *CollectOptionContext)

	// EnterForExpressionBody is called when entering the forExpressionBody production.
	EnterForExpressionBody(c *ForExpressionBodyContext)

	// EnterForExpressionReturn is called when entering the forExpressionReturn production.
	EnterForExpressionReturn(c *ForExpressionReturnContext)

	// EnterVariableDeclaration is called when entering the variableDeclaration production.
	EnterVariableDeclaration(c *VariableDeclarationContext)

	// EnterParam is called when entering the param production.
	EnterParam(c *ParamContext)

	// EnterVariable is called when entering the variable production.
	EnterVariable(c *VariableContext)

	// EnterRangeOperator is called when entering the rangeOperator production.
	EnterRangeOperator(c *RangeOperatorContext)

	// EnterArrayLiteral is called when entering the arrayLiteral production.
	EnterArrayLiteral(c *ArrayLiteralContext)

	// EnterObjectLiteral is called when entering the objectLiteral production.
	EnterObjectLiteral(c *ObjectLiteralContext)

	// EnterBooleanLiteral is called when entering the booleanLiteral production.
	EnterBooleanLiteral(c *BooleanLiteralContext)

	// EnterStringLiteral is called when entering the stringLiteral production.
	EnterStringLiteral(c *StringLiteralContext)

	// EnterIntegerLiteral is called when entering the integerLiteral production.
	EnterIntegerLiteral(c *IntegerLiteralContext)

	// EnterFloatLiteral is called when entering the floatLiteral production.
	EnterFloatLiteral(c *FloatLiteralContext)

	// EnterNoneLiteral is called when entering the noneLiteral production.
	EnterNoneLiteral(c *NoneLiteralContext)

	// EnterArrayElementList is called when entering the arrayElementList production.
	EnterArrayElementList(c *ArrayElementListContext)

	// EnterPropertyAssignment is called when entering the propertyAssignment production.
	EnterPropertyAssignment(c *PropertyAssignmentContext)

	// EnterMemberExpression is called when entering the memberExpression production.
	EnterMemberExpression(c *MemberExpressionContext)

	// EnterShorthandPropertyName is called when entering the shorthandPropertyName production.
	EnterShorthandPropertyName(c *ShorthandPropertyNameContext)

	// EnterComputedPropertyName is called when entering the computedPropertyName production.
	EnterComputedPropertyName(c *ComputedPropertyNameContext)

	// EnterPropertyName is called when entering the propertyName production.
	EnterPropertyName(c *PropertyNameContext)

	// EnterExpressionSequence is called when entering the expressionSequence production.
	EnterExpressionSequence(c *ExpressionSequenceContext)

	// EnterFunctionCallExpression is called when entering the functionCallExpression production.
	EnterFunctionCallExpression(c *FunctionCallExpressionContext)

	// EnterArguments is called when entering the arguments production.
	EnterArguments(c *ArgumentsContext)

	// EnterExpression is called when entering the expression production.
	EnterExpression(c *ExpressionContext)

	// EnterForTernaryExpression is called when entering the forTernaryExpression production.
	EnterForTernaryExpression(c *ForTernaryExpressionContext)

	// EnterArrayOperator is called when entering the arrayOperator production.
	EnterArrayOperator(c *ArrayOperatorContext)

	// EnterInOperator is called when entering the inOperator production.
	EnterInOperator(c *InOperatorContext)

	// EnterEqualityOperator is called when entering the equalityOperator production.
	EnterEqualityOperator(c *EqualityOperatorContext)

	// EnterLogicalOperator is called when entering the logicalOperator production.
	EnterLogicalOperator(c *LogicalOperatorContext)

	// EnterMathOperator is called when entering the mathOperator production.
	EnterMathOperator(c *MathOperatorContext)

	// EnterUnaryOperator is called when entering the unaryOperator production.
	EnterUnaryOperator(c *UnaryOperatorContext)

	// ExitProgram is called when exiting the program production.
	ExitProgram(c *ProgramContext)

	// ExitBody is called when exiting the body production.
	ExitBody(c *BodyContext)

	// ExitBodyStatement is called when exiting the bodyStatement production.
	ExitBodyStatement(c *BodyStatementContext)

	// ExitBodyExpression is called when exiting the bodyExpression production.
	ExitBodyExpression(c *BodyExpressionContext)

	// ExitReturnExpression is called when exiting the returnExpression production.
	ExitReturnExpression(c *ReturnExpressionContext)

	// ExitForExpression is called when exiting the forExpression production.
	ExitForExpression(c *ForExpressionContext)

	// ExitForExpressionValueVariable is called when exiting the forExpressionValueVariable production.
	ExitForExpressionValueVariable(c *ForExpressionValueVariableContext)

	// ExitForExpressionKeyVariable is called when exiting the forExpressionKeyVariable production.
	ExitForExpressionKeyVariable(c *ForExpressionKeyVariableContext)

	// ExitForExpressionSource is called when exiting the forExpressionSource production.
	ExitForExpressionSource(c *ForExpressionSourceContext)

	// ExitForExpressionClause is called when exiting the forExpressionClause production.
	ExitForExpressionClause(c *ForExpressionClauseContext)

	// ExitFilterClause is called when exiting the filterClause production.
	ExitFilterClause(c *FilterClauseContext)

	// ExitLimitClause is called when exiting the limitClause production.
	ExitLimitClause(c *LimitClauseContext)

	// ExitSortClause is called when exiting the sortClause production.
	ExitSortClause(c *SortClauseContext)

	// ExitSortClauseExpression is called when exiting the sortClauseExpression production.
	ExitSortClauseExpression(c *SortClauseExpressionContext)

	// ExitCollectClause is called when exiting the collectClause production.
	ExitCollectClause(c *CollectClauseContext)

	// ExitCollectVariable is called when exiting the collectVariable production.
	ExitCollectVariable(c *CollectVariableContext)

	// ExitCollectGroupVariable is called when exiting the collectGroupVariable production.
	ExitCollectGroupVariable(c *CollectGroupVariableContext)

	// ExitCollectKeepVariable is called when exiting the collectKeepVariable production.
	ExitCollectKeepVariable(c *CollectKeepVariableContext)

	// ExitCollectCountVariable is called when exiting the collectCountVariable production.
	ExitCollectCountVariable(c *CollectCountVariableContext)

	// ExitCollectAggregateVariable is called when exiting the collectAggregateVariable production.
	ExitCollectAggregateVariable(c *CollectAggregateVariableContext)

	// ExitCollectAggregateExpression is called when exiting the collectAggregateExpression production.
	ExitCollectAggregateExpression(c *CollectAggregateExpressionContext)

	// ExitCollectOption is called when exiting the collectOption production.
	ExitCollectOption(c *CollectOptionContext)

	// ExitForExpressionBody is called when exiting the forExpressionBody production.
	ExitForExpressionBody(c *ForExpressionBodyContext)

	// ExitForExpressionReturn is called when exiting the forExpressionReturn production.
	ExitForExpressionReturn(c *ForExpressionReturnContext)

	// ExitVariableDeclaration is called when exiting the variableDeclaration production.
	ExitVariableDeclaration(c *VariableDeclarationContext)

	// ExitParam is called when exiting the param production.
	ExitParam(c *ParamContext)

	// ExitVariable is called when exiting the variable production.
	ExitVariable(c *VariableContext)

	// ExitRangeOperator is called when exiting the rangeOperator production.
	ExitRangeOperator(c *RangeOperatorContext)

	// ExitArrayLiteral is called when exiting the arrayLiteral production.
	ExitArrayLiteral(c *ArrayLiteralContext)

	// ExitObjectLiteral is called when exiting the objectLiteral production.
	ExitObjectLiteral(c *ObjectLiteralContext)

	// ExitBooleanLiteral is called when exiting the booleanLiteral production.
	ExitBooleanLiteral(c *BooleanLiteralContext)

	// ExitStringLiteral is called when exiting the stringLiteral production.
	ExitStringLiteral(c *StringLiteralContext)

	// ExitIntegerLiteral is called when exiting the integerLiteral production.
	ExitIntegerLiteral(c *IntegerLiteralContext)

	// ExitFloatLiteral is called when exiting the floatLiteral production.
	ExitFloatLiteral(c *FloatLiteralContext)

	// ExitNoneLiteral is called when exiting the noneLiteral production.
	ExitNoneLiteral(c *NoneLiteralContext)

	// ExitArrayElementList is called when exiting the arrayElementList production.
	ExitArrayElementList(c *ArrayElementListContext)

	// ExitPropertyAssignment is called when exiting the propertyAssignment production.
	ExitPropertyAssignment(c *PropertyAssignmentContext)

	// ExitMemberExpression is called when exiting the memberExpression production.
	ExitMemberExpression(c *MemberExpressionContext)

	// ExitShorthandPropertyName is called when exiting the shorthandPropertyName production.
	ExitShorthandPropertyName(c *ShorthandPropertyNameContext)

	// ExitComputedPropertyName is called when exiting the computedPropertyName production.
	ExitComputedPropertyName(c *ComputedPropertyNameContext)

	// ExitPropertyName is called when exiting the propertyName production.
	ExitPropertyName(c *PropertyNameContext)

	// ExitExpressionSequence is called when exiting the expressionSequence production.
	ExitExpressionSequence(c *ExpressionSequenceContext)

	// ExitFunctionCallExpression is called when exiting the functionCallExpression production.
	ExitFunctionCallExpression(c *FunctionCallExpressionContext)

	// ExitArguments is called when exiting the arguments production.
	ExitArguments(c *ArgumentsContext)

	// ExitExpression is called when exiting the expression production.
	ExitExpression(c *ExpressionContext)

	// ExitForTernaryExpression is called when exiting the forTernaryExpression production.
	ExitForTernaryExpression(c *ForTernaryExpressionContext)

	// ExitArrayOperator is called when exiting the arrayOperator production.
	ExitArrayOperator(c *ArrayOperatorContext)

	// ExitInOperator is called when exiting the inOperator production.
	ExitInOperator(c *InOperatorContext)

	// ExitEqualityOperator is called when exiting the equalityOperator production.
	ExitEqualityOperator(c *EqualityOperatorContext)

	// ExitLogicalOperator is called when exiting the logicalOperator production.
	ExitLogicalOperator(c *LogicalOperatorContext)

	// ExitMathOperator is called when exiting the mathOperator production.
	ExitMathOperator(c *MathOperatorContext)

	// ExitUnaryOperator is called when exiting the unaryOperator production.
	ExitUnaryOperator(c *UnaryOperatorContext)
}

FqlParserListener is a complete listener for a parse tree produced by FqlParser.

type FqlParserVisitor 

type FqlParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by FqlParser#program.
	VisitProgram(ctx *ProgramContext) interface{}

	// Visit a parse tree produced by FqlParser#body.
	VisitBody(ctx *BodyContext) interface{}

	// Visit a parse tree produced by FqlParser#bodyStatement.
	VisitBodyStatement(ctx *BodyStatementContext) interface{}

	// Visit a parse tree produced by FqlParser#bodyExpression.
	VisitBodyExpression(ctx *BodyExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#returnExpression.
	VisitReturnExpression(ctx *ReturnExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpression.
	VisitForExpression(ctx *ForExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionValueVariable.
	VisitForExpressionValueVariable(ctx *ForExpressionValueVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionKeyVariable.
	VisitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionSource.
	VisitForExpressionSource(ctx *ForExpressionSourceContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionClause.
	VisitForExpressionClause(ctx *ForExpressionClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#filterClause.
	VisitFilterClause(ctx *FilterClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#limitClause.
	VisitLimitClause(ctx *LimitClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#sortClause.
	VisitSortClause(ctx *SortClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#sortClauseExpression.
	VisitSortClauseExpression(ctx *SortClauseExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#collectClause.
	VisitCollectClause(ctx *CollectClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#collectVariable.
	VisitCollectVariable(ctx *CollectVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectGroupVariable.
	VisitCollectGroupVariable(ctx *CollectGroupVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectKeepVariable.
	VisitCollectKeepVariable(ctx *CollectKeepVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectCountVariable.
	VisitCollectCountVariable(ctx *CollectCountVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectAggregateVariable.
	VisitCollectAggregateVariable(ctx *CollectAggregateVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectAggregateExpression.
	VisitCollectAggregateExpression(ctx *CollectAggregateExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#collectOption.
	VisitCollectOption(ctx *CollectOptionContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionBody.
	VisitForExpressionBody(ctx *ForExpressionBodyContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionReturn.
	VisitForExpressionReturn(ctx *ForExpressionReturnContext) interface{}

	// Visit a parse tree produced by FqlParser#variableDeclaration.
	VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

	// Visit a parse tree produced by FqlParser#param.
	VisitParam(ctx *ParamContext) interface{}

	// Visit a parse tree produced by FqlParser#variable.
	VisitVariable(ctx *VariableContext) interface{}

	// Visit a parse tree produced by FqlParser#rangeOperator.
	VisitRangeOperator(ctx *RangeOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayLiteral.
	VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#objectLiteral.
	VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#booleanLiteral.
	VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#stringLiteral.
	VisitStringLiteral(ctx *StringLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#integerLiteral.
	VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#floatLiteral.
	VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#noneLiteral.
	VisitNoneLiteral(ctx *NoneLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayElementList.
	VisitArrayElementList(ctx *ArrayElementListContext) interface{}

	// Visit a parse tree produced by FqlParser#propertyAssignment.
	VisitPropertyAssignment(ctx *PropertyAssignmentContext) interface{}

	// Visit a parse tree produced by FqlParser#memberExpression.
	VisitMemberExpression(ctx *MemberExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#shorthandPropertyName.
	VisitShorthandPropertyName(ctx *ShorthandPropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#computedPropertyName.
	VisitComputedPropertyName(ctx *ComputedPropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#propertyName.
	VisitPropertyName(ctx *PropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#expressionSequence.
	VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}

	// Visit a parse tree produced by FqlParser#functionCallExpression.
	VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#arguments.
	VisitArguments(ctx *ArgumentsContext) interface{}

	// Visit a parse tree produced by FqlParser#expression.
	VisitExpression(ctx *ExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forTernaryExpression.
	VisitForTernaryExpression(ctx *ForTernaryExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayOperator.
	VisitArrayOperator(ctx *ArrayOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#inOperator.
	VisitInOperator(ctx *InOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#equalityOperator.
	VisitEqualityOperator(ctx *EqualityOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#logicalOperator.
	VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#mathOperator.
	VisitMathOperator(ctx *MathOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#unaryOperator.
	VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}
}

A complete Visitor for a parse tree produced by FqlParser.

type FunctionCallExpressionContext 

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

func NewEmptyFunctionCallExpressionContext 

func NewEmptyFunctionCallExpressionContext() *FunctionCallExpressionContext

func NewFunctionCallExpressionContext 

func NewFunctionCallExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallExpressionContext

func (*FunctionCallExpressionContext) Accept 

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

func (*FunctionCallExpressionContext) Arguments 

func (s *FunctionCallExpressionContext) Arguments() IArgumentsContext

func (*FunctionCallExpressionContext) EnterRule 

func (s *FunctionCallExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionCallExpressionContext) ExitRule 

func (s *FunctionCallExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionCallExpressionContext) GetParser 

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

func (*FunctionCallExpressionContext) GetRuleContext 

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

func (*FunctionCallExpressionContext) Identifier 

func (s *FunctionCallExpressionContext) Identifier() antlr.TerminalNode

func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext 

func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext()

func (*FunctionCallExpressionContext) ToStringTree 

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

type IArgumentsContext 

type IArgumentsContext interface {
	antlr.ParserRuleContext

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

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

IArgumentsContext is an interface to support dynamic dispatch.

type IArrayElementListContext 

type IArrayElementListContext interface {
	antlr.ParserRuleContext

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

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

IArrayElementListContext is an interface to support dynamic dispatch.

type IArrayLiteralContext 

type IArrayLiteralContext interface {
	antlr.ParserRuleContext

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

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

IArrayLiteralContext is an interface to support dynamic dispatch.

type IArrayOperatorContext 

type IArrayOperatorContext interface {
	antlr.ParserRuleContext

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

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

IArrayOperatorContext is an interface to support dynamic dispatch.

type IBodyContext 

type IBodyContext interface {
	antlr.ParserRuleContext

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

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

IBodyContext is an interface to support dynamic dispatch.

type IBodyExpressionContext 

type IBodyExpressionContext interface {
	antlr.ParserRuleContext

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

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

IBodyExpressionContext is an interface to support dynamic dispatch.

type IBodyStatementContext 

type IBodyStatementContext interface {
	antlr.ParserRuleContext

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

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

IBodyStatementContext is an interface to support dynamic dispatch.

type IBooleanLiteralContext 

type IBooleanLiteralContext interface {
	antlr.ParserRuleContext

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

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

IBooleanLiteralContext is an interface to support dynamic dispatch.

type ICollectAggregateExpressionContext 

type ICollectAggregateExpressionContext interface {
	antlr.ParserRuleContext

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

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

ICollectAggregateExpressionContext is an interface to support dynamic dispatch.

type ICollectAggregateVariableContext 

type ICollectAggregateVariableContext interface {
	antlr.ParserRuleContext

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

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

ICollectAggregateVariableContext is an interface to support dynamic dispatch.

type ICollectClauseContext 

type ICollectClauseContext interface {
	antlr.ParserRuleContext

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

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

ICollectClauseContext is an interface to support dynamic dispatch.

type ICollectCountVariableContext 

type ICollectCountVariableContext interface {
	antlr.ParserRuleContext

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

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

ICollectCountVariableContext is an interface to support dynamic dispatch.

type ICollectGroupVariableContext 

type ICollectGroupVariableContext interface {
	antlr.ParserRuleContext

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

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

ICollectGroupVariableContext is an interface to support dynamic dispatch.

type ICollectKeepVariableContext 

type ICollectKeepVariableContext interface {
	antlr.ParserRuleContext

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

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

ICollectKeepVariableContext is an interface to support dynamic dispatch.

type ICollectOptionContext 

type ICollectOptionContext interface {
	antlr.ParserRuleContext

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

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

ICollectOptionContext is an interface to support dynamic dispatch.

type ICollectVariableContext 

type ICollectVariableContext interface {
	antlr.ParserRuleContext

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

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

ICollectVariableContext is an interface to support dynamic dispatch.

type IComputedPropertyNameContext 

type IComputedPropertyNameContext interface {
	antlr.ParserRuleContext

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

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

IComputedPropertyNameContext is an interface to support dynamic dispatch.

type IEqualityOperatorContext 

type IEqualityOperatorContext interface {
	antlr.ParserRuleContext

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

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

IEqualityOperatorContext is an interface to support dynamic dispatch.

type IExpressionContext 

type IExpressionContext interface {
	antlr.ParserRuleContext

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

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

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionSequenceContext 

type IExpressionSequenceContext interface {
	antlr.ParserRuleContext

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

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

IExpressionSequenceContext is an interface to support dynamic dispatch.

type IFilterClauseContext 

type IFilterClauseContext interface {
	antlr.ParserRuleContext

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

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

IFilterClauseContext is an interface to support dynamic dispatch.

type IFloatLiteralContext 

type IFloatLiteralContext interface {
	antlr.ParserRuleContext

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

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

IFloatLiteralContext is an interface to support dynamic dispatch.

type IForExpressionBodyContext 

type IForExpressionBodyContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionBodyContext is an interface to support dynamic dispatch.

type IForExpressionClauseContext 

type IForExpressionClauseContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionClauseContext is an interface to support dynamic dispatch.

type IForExpressionContext 

type IForExpressionContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionContext is an interface to support dynamic dispatch.

type IForExpressionKeyVariableContext 

type IForExpressionKeyVariableContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionKeyVariableContext is an interface to support dynamic dispatch.

type IForExpressionReturnContext 

type IForExpressionReturnContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionReturnContext is an interface to support dynamic dispatch.

type IForExpressionSourceContext 

type IForExpressionSourceContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionSourceContext is an interface to support dynamic dispatch.

type IForExpressionValueVariableContext 

type IForExpressionValueVariableContext interface {
	antlr.ParserRuleContext

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

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

IForExpressionValueVariableContext is an interface to support dynamic dispatch.

type IForTernaryExpressionContext 

type IForTernaryExpressionContext interface {
	antlr.ParserRuleContext

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

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

IForTernaryExpressionContext is an interface to support dynamic dispatch.

type IFunctionCallExpressionContext 

type IFunctionCallExpressionContext interface {
	antlr.ParserRuleContext

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

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

IFunctionCallExpressionContext is an interface to support dynamic dispatch.

type IInOperatorContext 

type IInOperatorContext interface {
	antlr.ParserRuleContext

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

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

IInOperatorContext is an interface to support dynamic dispatch.

type IIntegerLiteralContext 

type IIntegerLiteralContext interface {
	antlr.ParserRuleContext

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

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

IIntegerLiteralContext is an interface to support dynamic dispatch.

type ILimitClauseContext 

type ILimitClauseContext interface {
	antlr.ParserRuleContext

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

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

ILimitClauseContext is an interface to support dynamic dispatch.

type ILogicalOperatorContext 

type ILogicalOperatorContext interface {
	antlr.ParserRuleContext

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

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

ILogicalOperatorContext is an interface to support dynamic dispatch.

type IMathOperatorContext 

type IMathOperatorContext interface {
	antlr.ParserRuleContext

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

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

IMathOperatorContext is an interface to support dynamic dispatch.

type IMemberExpressionContext 

type IMemberExpressionContext interface {
	antlr.ParserRuleContext

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

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

IMemberExpressionContext is an interface to support dynamic dispatch.

type INoneLiteralContext 

type INoneLiteralContext interface {
	antlr.ParserRuleContext

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

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

INoneLiteralContext is an interface to support dynamic dispatch.

type IObjectLiteralContext 

type IObjectLiteralContext interface {
	antlr.ParserRuleContext

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

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

IObjectLiteralContext is an interface to support dynamic dispatch.

type IParamContext 

type IParamContext interface {
	antlr.ParserRuleContext

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

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

IParamContext is an interface to support dynamic dispatch.

type IProgramContext 

type IProgramContext interface {
	antlr.ParserRuleContext

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

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

IProgramContext is an interface to support dynamic dispatch.

type IPropertyAssignmentContext 

type IPropertyAssignmentContext interface {
	antlr.ParserRuleContext

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

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

IPropertyAssignmentContext is an interface to support dynamic dispatch.

type IPropertyNameContext 

type IPropertyNameContext interface {
	antlr.ParserRuleContext

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

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

IPropertyNameContext is an interface to support dynamic dispatch.

type IRangeOperatorContext 

type IRangeOperatorContext interface {
	antlr.ParserRuleContext

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

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

IRangeOperatorContext is an interface to support dynamic dispatch.

type IReturnExpressionContext 

type IReturnExpressionContext interface {
	antlr.ParserRuleContext

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

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

IReturnExpressionContext is an interface to support dynamic dispatch.

type IShorthandPropertyNameContext 

type IShorthandPropertyNameContext interface {
	antlr.ParserRuleContext

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

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

IShorthandPropertyNameContext is an interface to support dynamic dispatch.

type ISortClauseContext 

type ISortClauseContext interface {
	antlr.ParserRuleContext

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

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

ISortClauseContext is an interface to support dynamic dispatch.

type ISortClauseExpressionContext 

type ISortClauseExpressionContext interface {
	antlr.ParserRuleContext

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

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

ISortClauseExpressionContext is an interface to support dynamic dispatch.

type IStringLiteralContext 

type IStringLiteralContext interface {
	antlr.ParserRuleContext

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

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

IStringLiteralContext is an interface to support dynamic dispatch.

type IUnaryOperatorContext 

type IUnaryOperatorContext interface {
	antlr.ParserRuleContext

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

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

IUnaryOperatorContext is an interface to support dynamic dispatch.

type IVariableContext 

type IVariableContext interface {
	antlr.ParserRuleContext

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

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

IVariableContext is an interface to support dynamic dispatch.

type IVariableDeclarationContext 

type IVariableDeclarationContext interface {
	antlr.ParserRuleContext

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

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

IVariableDeclarationContext is an interface to support dynamic dispatch.

type InOperatorContext 

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

func NewEmptyInOperatorContext 

func NewEmptyInOperatorContext() *InOperatorContext

func NewInOperatorContext 

func NewInOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InOperatorContext

func (*InOperatorContext) Accept 

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

func (*InOperatorContext) EnterRule 

func (s *InOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*InOperatorContext) ExitRule 

func (s *InOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*InOperatorContext) GetParser 

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

func (*InOperatorContext) GetRuleContext 

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

func (*InOperatorContext) In 

func (s *InOperatorContext) In() antlr.TerminalNode

func (*InOperatorContext) IsInOperatorContext 

func (*InOperatorContext) IsInOperatorContext()

func (*InOperatorContext) ToStringTree 

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

type IntegerLiteralContext 

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

func NewEmptyIntegerLiteralContext 

func NewEmptyIntegerLiteralContext() *IntegerLiteralContext

func NewIntegerLiteralContext 

func NewIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerLiteralContext

func (*IntegerLiteralContext) Accept 

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

func (*IntegerLiteralContext) EnterRule 

func (s *IntegerLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*IntegerLiteralContext) ExitRule 

func (s *IntegerLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*IntegerLiteralContext) GetParser 

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

func (*IntegerLiteralContext) GetRuleContext 

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

func (*IntegerLiteralContext) IntegerLiteral 

func (s *IntegerLiteralContext) IntegerLiteral() antlr.TerminalNode

func (*IntegerLiteralContext) IsIntegerLiteralContext 

func (*IntegerLiteralContext) IsIntegerLiteralContext()

func (*IntegerLiteralContext) ToStringTree 

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

type LimitClauseContext 

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

func NewEmptyLimitClauseContext 

func NewEmptyLimitClauseContext() *LimitClauseContext

func NewLimitClauseContext 

func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext

func (*LimitClauseContext) Accept 

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

func (*LimitClauseContext) AllIntegerLiteral 

func (s *LimitClauseContext) AllIntegerLiteral() []antlr.TerminalNode

func (*LimitClauseContext) Comma 

func (s *LimitClauseContext) Comma() antlr.TerminalNode

func (*LimitClauseContext) EnterRule 

func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) ExitRule 

func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) GetParser 

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

func (*LimitClauseContext) GetRuleContext 

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

func (*LimitClauseContext) IntegerLiteral 

func (s *LimitClauseContext) IntegerLiteral(i int) antlr.TerminalNode

func (*LimitClauseContext) IsLimitClauseContext 

func (*LimitClauseContext) IsLimitClauseContext()

func (*LimitClauseContext) Limit 

func (s *LimitClauseContext) Limit() antlr.TerminalNode

func (*LimitClauseContext) ToStringTree 

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

type LogicalOperatorContext 

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

func NewEmptyLogicalOperatorContext 

func NewEmptyLogicalOperatorContext() *LogicalOperatorContext

func NewLogicalOperatorContext 

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

func (*LogicalOperatorContext) Accept 

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

func (*LogicalOperatorContext) And 

func (s *LogicalOperatorContext) And() antlr.TerminalNode

func (*LogicalOperatorContext) EnterRule 

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

func (*LogicalOperatorContext) ExitRule 

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

func (*LogicalOperatorContext) GetParser 

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

func (*LogicalOperatorContext) GetRuleContext 

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

func (*LogicalOperatorContext) IsLogicalOperatorContext 

func (*LogicalOperatorContext) IsLogicalOperatorContext()

func (*LogicalOperatorContext) Or 

func (s *LogicalOperatorContext) Or() antlr.TerminalNode

func (*LogicalOperatorContext) ToStringTree 

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

type MathOperatorContext 

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

func NewEmptyMathOperatorContext 

func NewEmptyMathOperatorContext() *MathOperatorContext

func NewMathOperatorContext 

func NewMathOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathOperatorContext

func (*MathOperatorContext) Accept 

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

func (*MathOperatorContext) Div 

func (s *MathOperatorContext) Div() antlr.TerminalNode

func (*MathOperatorContext) EnterRule 

func (s *MathOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*MathOperatorContext) ExitRule 

func (s *MathOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*MathOperatorContext) GetParser 

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

func (*MathOperatorContext) GetRuleContext 

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

func (*MathOperatorContext) IsMathOperatorContext 

func (*MathOperatorContext) IsMathOperatorContext()

func (*MathOperatorContext) Minus 

func (s *MathOperatorContext) Minus() antlr.TerminalNode

func (*MathOperatorContext) Mod 

func (s *MathOperatorContext) Mod() antlr.TerminalNode

func (*MathOperatorContext) Multi 

func (s *MathOperatorContext) Multi() antlr.TerminalNode

func (*MathOperatorContext) Plus 

func (s *MathOperatorContext) Plus() antlr.TerminalNode

func (*MathOperatorContext) ToStringTree 

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

type MemberExpressionContext 

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

func NewEmptyMemberExpressionContext 

func NewEmptyMemberExpressionContext() *MemberExpressionContext

func NewMemberExpressionContext 

func NewMemberExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberExpressionContext

func (*MemberExpressionContext) Accept 

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

func (*MemberExpressionContext) AllComputedPropertyName 

func (s *MemberExpressionContext) AllComputedPropertyName() []IComputedPropertyNameContext

func (*MemberExpressionContext) AllDot 

func (s *MemberExpressionContext) AllDot() []antlr.TerminalNode

func (*MemberExpressionContext) AllPropertyName 

func (s *MemberExpressionContext) AllPropertyName() []IPropertyNameContext

func (*MemberExpressionContext) ComputedPropertyName 

func (s *MemberExpressionContext) ComputedPropertyName(i int) IComputedPropertyNameContext

func (*MemberExpressionContext) Dot 

func (s *MemberExpressionContext) Dot(i int) antlr.TerminalNode

func (*MemberExpressionContext) EnterRule 

func (s *MemberExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*MemberExpressionContext) ExitRule 

func (s *MemberExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*MemberExpressionContext) GetParser 

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

func (*MemberExpressionContext) GetRuleContext 

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

func (*MemberExpressionContext) Identifier 

func (s *MemberExpressionContext) Identifier() antlr.TerminalNode

func (*MemberExpressionContext) IsMemberExpressionContext 

func (*MemberExpressionContext) IsMemberExpressionContext()

func (*MemberExpressionContext) PropertyName 

func (s *MemberExpressionContext) PropertyName(i int) IPropertyNameContext

func (*MemberExpressionContext) ToStringTree 

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

type NoneLiteralContext 

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

func NewEmptyNoneLiteralContext 

func NewEmptyNoneLiteralContext() *NoneLiteralContext

func NewNoneLiteralContext 

func NewNoneLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NoneLiteralContext

func (*NoneLiteralContext) Accept 

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

func (*NoneLiteralContext) EnterRule 

func (s *NoneLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*NoneLiteralContext) ExitRule 

func (s *NoneLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*NoneLiteralContext) GetParser 

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

func (*NoneLiteralContext) GetRuleContext 

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

func (*NoneLiteralContext) IsNoneLiteralContext 

func (*NoneLiteralContext) IsNoneLiteralContext()

func (*NoneLiteralContext) None 

func (s *NoneLiteralContext) None() antlr.TerminalNode

func (*NoneLiteralContext) Null 

func (s *NoneLiteralContext) Null() antlr.TerminalNode

func (*NoneLiteralContext) ToStringTree 

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

type ObjectLiteralContext 

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

func NewEmptyObjectLiteralContext 

func NewEmptyObjectLiteralContext() *ObjectLiteralContext

func NewObjectLiteralContext 

func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext

func (*ObjectLiteralContext) Accept 

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

func (*ObjectLiteralContext) AllComma 

func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode

func (*ObjectLiteralContext) AllPropertyAssignment 

func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext

func (*ObjectLiteralContext) CloseBrace 

func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode

func (*ObjectLiteralContext) Comma 

func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode

func (*ObjectLiteralContext) EnterRule 

func (s *ObjectLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*ObjectLiteralContext) ExitRule 

func (s *ObjectLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*ObjectLiteralContext) GetParser 

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

func (*ObjectLiteralContext) GetRuleContext 

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

func (*ObjectLiteralContext) IsObjectLiteralContext 

func (*ObjectLiteralContext) IsObjectLiteralContext()

func (*ObjectLiteralContext) OpenBrace 

func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode

func (*ObjectLiteralContext) PropertyAssignment 

func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext

func (*ObjectLiteralContext) ToStringTree 

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

type ParamContext 

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

func NewEmptyParamContext 

func NewEmptyParamContext() *ParamContext

func NewParamContext 

func NewParamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamContext

func (*ParamContext) Accept 

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

func (*ParamContext) EnterRule 

func (s *ParamContext) EnterRule(listener antlr.ParseTreeListener)

func (*ParamContext) ExitRule 

func (s *ParamContext) ExitRule(listener antlr.ParseTreeListener)

func (*ParamContext) GetParser 

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

func (*ParamContext) GetRuleContext 

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

func (*ParamContext) Identifier 

func (s *ParamContext) Identifier() antlr.TerminalNode

func (*ParamContext) IsParamContext 

func (*ParamContext) IsParamContext()

func (*ParamContext) Param 

func (s *ParamContext) Param() antlr.TerminalNode

func (*ParamContext) ToStringTree 

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

type ProgramContext 

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

func NewEmptyProgramContext 

func NewEmptyProgramContext() *ProgramContext

func NewProgramContext 

func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

func (*ProgramContext) Accept 

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

func (*ProgramContext) Body 

func (s *ProgramContext) Body() IBodyContext

func (*ProgramContext) EnterRule 

func (s *ProgramContext) EnterRule(listener antlr.ParseTreeListener)

func (*ProgramContext) ExitRule 

func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener)

func (*ProgramContext) GetParser 

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

func (*ProgramContext) GetRuleContext 

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

func (*ProgramContext) IsProgramContext 

func (*ProgramContext) IsProgramContext()

func (*ProgramContext) ToStringTree 

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

type PropertyAssignmentContext 

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

func NewEmptyPropertyAssignmentContext 

func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext

func NewPropertyAssignmentContext 

func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext

func (*PropertyAssignmentContext) Accept 

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

func (*PropertyAssignmentContext) Colon 

func (s *PropertyAssignmentContext) Colon() antlr.TerminalNode

func (*PropertyAssignmentContext) ComputedPropertyName 

func (s *PropertyAssignmentContext) ComputedPropertyName() IComputedPropertyNameContext

func (*PropertyAssignmentContext) EnterRule 

func (s *PropertyAssignmentContext) EnterRule(listener antlr.ParseTreeListener)

func (*PropertyAssignmentContext) ExitRule 

func (s *PropertyAssignmentContext) ExitRule(listener antlr.ParseTreeListener)

func (*PropertyAssignmentContext) Expression 

func (s *PropertyAssignmentContext) Expression() IExpressionContext

func (*PropertyAssignmentContext) GetParser 

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

func (*PropertyAssignmentContext) GetRuleContext 

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

func (*PropertyAssignmentContext) IsPropertyAssignmentContext 

func (*PropertyAssignmentContext) IsPropertyAssignmentContext()

func (*PropertyAssignmentContext) PropertyName 

func (s *PropertyAssignmentContext) PropertyName() IPropertyNameContext

func (*PropertyAssignmentContext) ShorthandPropertyName 

func (s *PropertyAssignmentContext) ShorthandPropertyName() IShorthandPropertyNameContext

func (*PropertyAssignmentContext) ToStringTree 

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

type PropertyNameContext 

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

func NewEmptyPropertyNameContext 

func NewEmptyPropertyNameContext() *PropertyNameContext

func NewPropertyNameContext 

func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext

func (*PropertyNameContext) Accept 

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

func (*PropertyNameContext) EnterRule 

func (s *PropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*PropertyNameContext) ExitRule 

func (s *PropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*PropertyNameContext) GetParser 

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

func (*PropertyNameContext) GetRuleContext 

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

func (*PropertyNameContext) Identifier 

func (s *PropertyNameContext) Identifier() antlr.TerminalNode

func (*PropertyNameContext) IsPropertyNameContext 

func (*PropertyNameContext) IsPropertyNameContext()

func (*PropertyNameContext) ToStringTree 

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

type RangeOperatorContext 

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

func NewEmptyRangeOperatorContext 

func NewEmptyRangeOperatorContext() *RangeOperatorContext

func NewRangeOperatorContext 

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

func (*RangeOperatorContext) Accept 

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

func (*RangeOperatorContext) AllIntegerLiteral 

func (s *RangeOperatorContext) AllIntegerLiteral() []IIntegerLiteralContext

func (*RangeOperatorContext) AllParam 

func (s *RangeOperatorContext) AllParam() []IParamContext

func (*RangeOperatorContext) AllVariable 

func (s *RangeOperatorContext) AllVariable() []IVariableContext

func (*RangeOperatorContext) EnterRule 

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

func (*RangeOperatorContext) ExitRule 

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

func (*RangeOperatorContext) GetParser 

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

func (*RangeOperatorContext) GetRuleContext 

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

func (*RangeOperatorContext) IntegerLiteral 

func (s *RangeOperatorContext) IntegerLiteral(i int) IIntegerLiteralContext

func (*RangeOperatorContext) IsRangeOperatorContext 

func (*RangeOperatorContext) IsRangeOperatorContext()

func (*RangeOperatorContext) Param 

func (s *RangeOperatorContext) Param(i int) IParamContext

func (*RangeOperatorContext) Range 

func (s *RangeOperatorContext) Range() antlr.TerminalNode

func (*RangeOperatorContext) ToStringTree 

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

func (*RangeOperatorContext) Variable 

func (s *RangeOperatorContext) Variable(i int) IVariableContext

type ReturnExpressionContext 

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

func NewEmptyReturnExpressionContext 

func NewEmptyReturnExpressionContext() *ReturnExpressionContext

func NewReturnExpressionContext 

func NewReturnExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnExpressionContext

func (*ReturnExpressionContext) Accept 

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

func (*ReturnExpressionContext) CloseParen 

func (s *ReturnExpressionContext) CloseParen() antlr.TerminalNode

func (*ReturnExpressionContext) Distinct 

func (s *ReturnExpressionContext) Distinct() antlr.TerminalNode

func (*ReturnExpressionContext) EnterRule 

func (s *ReturnExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ReturnExpressionContext) ExitRule 

func (s *ReturnExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ReturnExpressionContext) Expression 

func (s *ReturnExpressionContext) Expression() IExpressionContext

func (*ReturnExpressionContext) ForExpression 

func (s *ReturnExpressionContext) ForExpression() IForExpressionContext

func (*ReturnExpressionContext) ForTernaryExpression 

func (s *ReturnExpressionContext) ForTernaryExpression() IForTernaryExpressionContext

func (*ReturnExpressionContext) GetParser 

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

func (*ReturnExpressionContext) GetRuleContext 

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

func (*ReturnExpressionContext) IsReturnExpressionContext 

func (*ReturnExpressionContext) IsReturnExpressionContext()

func (*ReturnExpressionContext) OpenParen 

func (s *ReturnExpressionContext) OpenParen() antlr.TerminalNode

func (*ReturnExpressionContext) Return 

func (s *ReturnExpressionContext) Return() antlr.TerminalNode

func (*ReturnExpressionContext) ToStringTree 

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

type ShorthandPropertyNameContext 

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

func NewEmptyShorthandPropertyNameContext 

func NewEmptyShorthandPropertyNameContext() *ShorthandPropertyNameContext

func NewShorthandPropertyNameContext 

func NewShorthandPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShorthandPropertyNameContext

func (*ShorthandPropertyNameContext) Accept 

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

func (*ShorthandPropertyNameContext) EnterRule 

func (s *ShorthandPropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*ShorthandPropertyNameContext) ExitRule 

func (s *ShorthandPropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*ShorthandPropertyNameContext) GetParser 

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

func (*ShorthandPropertyNameContext) GetRuleContext 

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

func (*ShorthandPropertyNameContext) IsShorthandPropertyNameContext 

func (*ShorthandPropertyNameContext) IsShorthandPropertyNameContext()

func (*ShorthandPropertyNameContext) ToStringTree 

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

func (*ShorthandPropertyNameContext) Variable 

func (s *ShorthandPropertyNameContext) Variable() IVariableContext

type SortClauseContext 

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

func NewEmptySortClauseContext 

func NewEmptySortClauseContext() *SortClauseContext

func NewSortClauseContext 

func NewSortClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseContext

func (*SortClauseContext) Accept 

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

func (*SortClauseContext) AllComma 

func (s *SortClauseContext) AllComma() []antlr.TerminalNode

func (*SortClauseContext) AllSortClauseExpression 

func (s *SortClauseContext) AllSortClauseExpression() []ISortClauseExpressionContext

func (*SortClauseContext) Comma 

func (s *SortClauseContext) Comma(i int) antlr.TerminalNode

func (*SortClauseContext) EnterRule 

func (s *SortClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*SortClauseContext) ExitRule 

func (s *SortClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*SortClauseContext) GetParser 

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

func (*SortClauseContext) GetRuleContext 

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

func (*SortClauseContext) IsSortClauseContext 

func (*SortClauseContext) IsSortClauseContext()

func (*SortClauseContext) Sort 

func (s *SortClauseContext) Sort() antlr.TerminalNode

func (*SortClauseContext) SortClauseExpression 

func (s *SortClauseContext) SortClauseExpression(i int) ISortClauseExpressionContext

func (*SortClauseContext) ToStringTree 

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

type SortClauseExpressionContext 

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

func NewEmptySortClauseExpressionContext 

func NewEmptySortClauseExpressionContext() *SortClauseExpressionContext

func NewSortClauseExpressionContext 

func NewSortClauseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseExpressionContext

func (*SortClauseExpressionContext) Accept 

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

func (*SortClauseExpressionContext) EnterRule 

func (s *SortClauseExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*SortClauseExpressionContext) ExitRule 

func (s *SortClauseExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*SortClauseExpressionContext) Expression 

func (s *SortClauseExpressionContext) Expression() IExpressionContext

func (*SortClauseExpressionContext) GetParser 

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

func (*SortClauseExpressionContext) GetRuleContext 

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

func (*SortClauseExpressionContext) IsSortClauseExpressionContext 

func (*SortClauseExpressionContext) IsSortClauseExpressionContext()

func (*SortClauseExpressionContext) SortDirection 

func (s *SortClauseExpressionContext) SortDirection() antlr.TerminalNode

func (*SortClauseExpressionContext) ToStringTree 

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

type StringLiteralContext 

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

func NewEmptyStringLiteralContext 

func NewEmptyStringLiteralContext() *StringLiteralContext

func NewStringLiteralContext 

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

func (*StringLiteralContext) Accept 

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

func (*StringLiteralContext) EnterRule 

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

func (*StringLiteralContext) ExitRule 

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

func (*StringLiteralContext) GetParser 

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

func (*StringLiteralContext) GetRuleContext 

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

func (*StringLiteralContext) IsStringLiteralContext 

func (*StringLiteralContext) IsStringLiteralContext()

func (*StringLiteralContext) StringLiteral 

func (s *StringLiteralContext) StringLiteral() antlr.TerminalNode

func (*StringLiteralContext) ToStringTree 

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

type UnaryOperatorContext 

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

func NewEmptyUnaryOperatorContext 

func NewEmptyUnaryOperatorContext() *UnaryOperatorContext

func NewUnaryOperatorContext 

func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext

func (*UnaryOperatorContext) Accept 

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

func (*UnaryOperatorContext) EnterRule 

func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) ExitRule 

func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) GetParser 

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

func (*UnaryOperatorContext) GetRuleContext 

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

func (*UnaryOperatorContext) IsUnaryOperatorContext 

func (*UnaryOperatorContext) IsUnaryOperatorContext()

func (*UnaryOperatorContext) Like 

func (s *UnaryOperatorContext) Like() antlr.TerminalNode

func (*UnaryOperatorContext) Minus 

func (s *UnaryOperatorContext) Minus() antlr.TerminalNode

func (*UnaryOperatorContext) Not 

func (s *UnaryOperatorContext) Not() antlr.TerminalNode

func (*UnaryOperatorContext) Plus 

func (s *UnaryOperatorContext) Plus() antlr.TerminalNode

func (*UnaryOperatorContext) ToStringTree 

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

type VariableContext 

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

func NewEmptyVariableContext 

func NewEmptyVariableContext() *VariableContext

func NewVariableContext 

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

func (*VariableContext) Accept 

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

func (*VariableContext) EnterRule 

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

func (*VariableContext) ExitRule 

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

func (*VariableContext) GetParser 

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

func (*VariableContext) GetRuleContext 

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

func (*VariableContext) Identifier 

func (s *VariableContext) Identifier() antlr.TerminalNode

func (*VariableContext) IsVariableContext 

func (*VariableContext) IsVariableContext()

func (*VariableContext) ToStringTree 

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

type VariableDeclarationContext 

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

func NewEmptyVariableDeclarationContext 

func NewEmptyVariableDeclarationContext() *VariableDeclarationContext

func NewVariableDeclarationContext 

func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext

func (*VariableDeclarationContext) Accept 

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

func (*VariableDeclarationContext) Assign 

func (s *VariableDeclarationContext) Assign() antlr.TerminalNode

func (*VariableDeclarationContext) CloseParen 

func (s *VariableDeclarationContext) CloseParen() antlr.TerminalNode

func (*VariableDeclarationContext) EnterRule 

func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener)

func (*VariableDeclarationContext) ExitRule 

func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener)

func (*VariableDeclarationContext) Expression 

func (s *VariableDeclarationContext) Expression() IExpressionContext

func (*VariableDeclarationContext) ForExpression 

func (s *VariableDeclarationContext) ForExpression() IForExpressionContext

func (*VariableDeclarationContext) ForTernaryExpression 

func (s *VariableDeclarationContext) ForTernaryExpression() IForTernaryExpressionContext

func (*VariableDeclarationContext) GetParser 

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

func (*VariableDeclarationContext) GetRuleContext 

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

func (*VariableDeclarationContext) Identifier 

func (s *VariableDeclarationContext) Identifier() antlr.TerminalNode

func (*VariableDeclarationContext) IsVariableDeclarationContext 

func (*VariableDeclarationContext) IsVariableDeclarationContext()

func (*VariableDeclarationContext) Let 

func (s *VariableDeclarationContext) Let() antlr.TerminalNode

func (*VariableDeclarationContext) OpenParen 

func (s *VariableDeclarationContext) OpenParen() antlr.TerminalNode

func (*VariableDeclarationContext) ToStringTree 

func (s *VariableDeclarationContext) 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.