ecmascript

package
v0.0.0-...-4c43aeb Latest Latest
Warning

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

 Go to latest Published: Jan 4, 2022 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Example 
package main

import (
	"bramp.net/antlr4/ecmascript"

	"fmt"
	"github.com/antlr/antlr4/runtime/Go/antlr"
)

type exampleListener struct {
	*ecmascript.BaseECMAScriptListener
}

func (l *exampleListener) EnterEveryRule(ctx antlr.ParserRuleContext) {
	fmt.Println(ctx.GetText())
}
func main() {
	// Setup the input
	is := antlr.NewInputStream("...some text to parse...")

	// Create the Lexer
	lexer := ecmascript.NewECMAScriptLexer(is)
	stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)

	// Create the Parser
	p := ecmascript.NewECMAScriptParser(stream)
	p.BuildParseTrees = true
	p.AddErrorListener(antlr.NewDiagnosticErrorListener(true))

	// Finally walk the tree
	tree := p.Program()
	antlr.ParseTreeWalkerDefault.Walk(&exampleListener{}, tree)
}

Output:

Index

Examples

Constants

View Source 
const (
	ECMAScriptLexerRegularExpressionLiteral   = 1
	ECMAScriptLexerLineTerminator             = 2
	ECMAScriptLexerOpenBracket                = 3
	ECMAScriptLexerCloseBracket               = 4
	ECMAScriptLexerOpenParen                  = 5
	ECMAScriptLexerCloseParen                 = 6
	ECMAScriptLexerOpenBrace                  = 7
	ECMAScriptLexerCloseBrace                 = 8
	ECMAScriptLexerSemiColon                  = 9
	ECMAScriptLexerComma                      = 10
	ECMAScriptLexerAssign                     = 11
	ECMAScriptLexerQuestionMark               = 12
	ECMAScriptLexerColon                      = 13
	ECMAScriptLexerDot                        = 14
	ECMAScriptLexerPlusPlus                   = 15
	ECMAScriptLexerMinusMinus                 = 16
	ECMAScriptLexerPlus                       = 17
	ECMAScriptLexerMinus                      = 18
	ECMAScriptLexerBitNot                     = 19
	ECMAScriptLexerNot                        = 20
	ECMAScriptLexerMultiply                   = 21
	ECMAScriptLexerDivide                     = 22
	ECMAScriptLexerModulus                    = 23
	ECMAScriptLexerRightShiftArithmetic       = 24
	ECMAScriptLexerLeftShiftArithmetic        = 25
	ECMAScriptLexerRightShiftLogical          = 26
	ECMAScriptLexerLessThan                   = 27
	ECMAScriptLexerMoreThan                   = 28
	ECMAScriptLexerLessThanEquals             = 29
	ECMAScriptLexerGreaterThanEquals          = 30
	ECMAScriptLexerEquals                     = 31
	ECMAScriptLexerNotEquals                  = 32
	ECMAScriptLexerIdentityEquals             = 33
	ECMAScriptLexerIdentityNotEquals          = 34
	ECMAScriptLexerBitAnd                     = 35
	ECMAScriptLexerBitXOr                     = 36
	ECMAScriptLexerBitOr                      = 37
	ECMAScriptLexerAnd                        = 38
	ECMAScriptLexerOr                         = 39
	ECMAScriptLexerMultiplyAssign             = 40
	ECMAScriptLexerDivideAssign               = 41
	ECMAScriptLexerModulusAssign              = 42
	ECMAScriptLexerPlusAssign                 = 43
	ECMAScriptLexerMinusAssign                = 44
	ECMAScriptLexerLeftShiftArithmeticAssign  = 45
	ECMAScriptLexerRightShiftArithmeticAssign = 46
	ECMAScriptLexerRightShiftLogicalAssign    = 47
	ECMAScriptLexerBitAndAssign               = 48
	ECMAScriptLexerBitXorAssign               = 49
	ECMAScriptLexerBitOrAssign                = 50
	ECMAScriptLexerNullLiteral                = 51
	ECMAScriptLexerBooleanLiteral             = 52
	ECMAScriptLexerDecimalLiteral             = 53
	ECMAScriptLexerHexIntegerLiteral          = 54
	ECMAScriptLexerOctalIntegerLiteral        = 55
	ECMAScriptLexerBreak                      = 56
	ECMAScriptLexerDo                         = 57
	ECMAScriptLexerInstanceof                 = 58
	ECMAScriptLexerTypeof                     = 59
	ECMAScriptLexerCase                       = 60
	ECMAScriptLexerElse                       = 61
	ECMAScriptLexerNew                        = 62
	ECMAScriptLexerVar                        = 63
	ECMAScriptLexerCatch                      = 64
	ECMAScriptLexerFinally                    = 65
	ECMAScriptLexerReturn                     = 66
	ECMAScriptLexerVoid                       = 67
	ECMAScriptLexerContinue                   = 68
	ECMAScriptLexerFor                        = 69
	ECMAScriptLexerSwitch                     = 70
	ECMAScriptLexerWhile                      = 71
	ECMAScriptLexerDebugger                   = 72
	ECMAScriptLexerFunction                   = 73
	ECMAScriptLexerThis                       = 74
	ECMAScriptLexerWith                       = 75
	ECMAScriptLexerDefault                    = 76
	ECMAScriptLexerIf                         = 77
	ECMAScriptLexerThrow                      = 78
	ECMAScriptLexerDelete                     = 79
	ECMAScriptLexerIn                         = 80
	ECMAScriptLexerTry                        = 81
	ECMAScriptLexerClass                      = 82
	ECMAScriptLexerEnum                       = 83
	ECMAScriptLexerExtends                    = 84
	ECMAScriptLexerSuper                      = 85
	ECMAScriptLexerConst                      = 86
	ECMAScriptLexerExport                     = 87
	ECMAScriptLexerImport                     = 88
	ECMAScriptLexerImplements                 = 89
	ECMAScriptLexerLet                        = 90
	ECMAScriptLexerPrivate                    = 91
	ECMAScriptLexerPublic                     = 92
	ECMAScriptLexerInterface                  = 93
	ECMAScriptLexerPackage                    = 94
	ECMAScriptLexerProtected                  = 95
	ECMAScriptLexerStatic                     = 96
	ECMAScriptLexerYield                      = 97
	ECMAScriptLexerIdentifier                 = 98
	ECMAScriptLexerStringLiteral              = 99
	ECMAScriptLexerWhiteSpaces                = 100
	ECMAScriptLexerMultiLineComment           = 101
	ECMAScriptLexerSingleLineComment          = 102
	ECMAScriptLexerUnexpectedCharacter        = 103
)

ECMAScriptLexer tokens.

View Source 
const (
	ECMAScriptParserEOF                        = antlr.TokenEOF
	ECMAScriptParserRegularExpressionLiteral   = 1
	ECMAScriptParserLineTerminator             = 2
	ECMAScriptParserOpenBracket                = 3
	ECMAScriptParserCloseBracket               = 4
	ECMAScriptParserOpenParen                  = 5
	ECMAScriptParserCloseParen                 = 6
	ECMAScriptParserOpenBrace                  = 7
	ECMAScriptParserCloseBrace                 = 8
	ECMAScriptParserSemiColon                  = 9
	ECMAScriptParserComma                      = 10
	ECMAScriptParserAssign                     = 11
	ECMAScriptParserQuestionMark               = 12
	ECMAScriptParserColon                      = 13
	ECMAScriptParserDot                        = 14
	ECMAScriptParserPlusPlus                   = 15
	ECMAScriptParserMinusMinus                 = 16
	ECMAScriptParserPlus                       = 17
	ECMAScriptParserMinus                      = 18
	ECMAScriptParserBitNot                     = 19
	ECMAScriptParserNot                        = 20
	ECMAScriptParserMultiply                   = 21
	ECMAScriptParserDivide                     = 22
	ECMAScriptParserModulus                    = 23
	ECMAScriptParserRightShiftArithmetic       = 24
	ECMAScriptParserLeftShiftArithmetic        = 25
	ECMAScriptParserRightShiftLogical          = 26
	ECMAScriptParserLessThan                   = 27
	ECMAScriptParserMoreThan                   = 28
	ECMAScriptParserLessThanEquals             = 29
	ECMAScriptParserGreaterThanEquals          = 30
	ECMAScriptParserEquals                     = 31
	ECMAScriptParserNotEquals                  = 32
	ECMAScriptParserIdentityEquals             = 33
	ECMAScriptParserIdentityNotEquals          = 34
	ECMAScriptParserBitAnd                     = 35
	ECMAScriptParserBitXOr                     = 36
	ECMAScriptParserBitOr                      = 37
	ECMAScriptParserAnd                        = 38
	ECMAScriptParserOr                         = 39
	ECMAScriptParserMultiplyAssign             = 40
	ECMAScriptParserDivideAssign               = 41
	ECMAScriptParserModulusAssign              = 42
	ECMAScriptParserPlusAssign                 = 43
	ECMAScriptParserMinusAssign                = 44
	ECMAScriptParserLeftShiftArithmeticAssign  = 45
	ECMAScriptParserRightShiftArithmeticAssign = 46
	ECMAScriptParserRightShiftLogicalAssign    = 47
	ECMAScriptParserBitAndAssign               = 48
	ECMAScriptParserBitXorAssign               = 49
	ECMAScriptParserBitOrAssign                = 50
	ECMAScriptParserNullLiteral                = 51
	ECMAScriptParserBooleanLiteral             = 52
	ECMAScriptParserDecimalLiteral             = 53
	ECMAScriptParserHexIntegerLiteral          = 54
	ECMAScriptParserOctalIntegerLiteral        = 55
	ECMAScriptParserBreak                      = 56
	ECMAScriptParserDo                         = 57
	ECMAScriptParserInstanceof                 = 58
	ECMAScriptParserTypeof                     = 59
	ECMAScriptParserCase                       = 60
	ECMAScriptParserElse                       = 61
	ECMAScriptParserNew                        = 62
	ECMAScriptParserVar                        = 63
	ECMAScriptParserCatch                      = 64
	ECMAScriptParserFinally                    = 65
	ECMAScriptParserReturn                     = 66
	ECMAScriptParserVoid                       = 67
	ECMAScriptParserContinue                   = 68
	ECMAScriptParserFor                        = 69
	ECMAScriptParserSwitch                     = 70
	ECMAScriptParserWhile                      = 71
	ECMAScriptParserDebugger                   = 72
	ECMAScriptParserFunction                   = 73
	ECMAScriptParserThis                       = 74
	ECMAScriptParserWith                       = 75
	ECMAScriptParserDefault                    = 76
	ECMAScriptParserIf                         = 77
	ECMAScriptParserThrow                      = 78
	ECMAScriptParserDelete                     = 79
	ECMAScriptParserIn                         = 80
	ECMAScriptParserTry                        = 81
	ECMAScriptParserClass                      = 82
	ECMAScriptParserEnum                       = 83
	ECMAScriptParserExtends                    = 84
	ECMAScriptParserSuper                      = 85
	ECMAScriptParserConst                      = 86
	ECMAScriptParserExport                     = 87
	ECMAScriptParserImport                     = 88
	ECMAScriptParserImplements                 = 89
	ECMAScriptParserLet                        = 90
	ECMAScriptParserPrivate                    = 91
	ECMAScriptParserPublic                     = 92
	ECMAScriptParserInterface                  = 93
	ECMAScriptParserPackage                    = 94
	ECMAScriptParserProtected                  = 95
	ECMAScriptParserStatic                     = 96
	ECMAScriptParserYield                      = 97
	ECMAScriptParserIdentifier                 = 98
	ECMAScriptParserStringLiteral              = 99
	ECMAScriptParserWhiteSpaces                = 100
	ECMAScriptParserMultiLineComment           = 101
	ECMAScriptParserSingleLineComment          = 102
	ECMAScriptParserUnexpectedCharacter        = 103
)

ECMAScriptParser tokens.

View Source 
const (
	ECMAScriptParserRULE_program                  = 0
	ECMAScriptParserRULE_sourceElements           = 1
	ECMAScriptParserRULE_sourceElement            = 2
	ECMAScriptParserRULE_statement                = 3
	ECMAScriptParserRULE_block                    = 4
	ECMAScriptParserRULE_statementList            = 5
	ECMAScriptParserRULE_variableStatement        = 6
	ECMAScriptParserRULE_variableDeclarationList  = 7
	ECMAScriptParserRULE_variableDeclaration      = 8
	ECMAScriptParserRULE_initialiser              = 9
	ECMAScriptParserRULE_voidStatement            = 10
	ECMAScriptParserRULE_expressionStatement      = 11
	ECMAScriptParserRULE_ifStatement              = 12
	ECMAScriptParserRULE_iterationStatement       = 13
	ECMAScriptParserRULE_continueStatement        = 14
	ECMAScriptParserRULE_breakStatement           = 15
	ECMAScriptParserRULE_returnStatement          = 16
	ECMAScriptParserRULE_withStatement            = 17
	ECMAScriptParserRULE_switchStatement          = 18
	ECMAScriptParserRULE_caseBlock                = 19
	ECMAScriptParserRULE_caseClauses              = 20
	ECMAScriptParserRULE_caseClause               = 21
	ECMAScriptParserRULE_defaultClause            = 22
	ECMAScriptParserRULE_labelledStatement        = 23
	ECMAScriptParserRULE_throwStatement           = 24
	ECMAScriptParserRULE_tryStatement             = 25
	ECMAScriptParserRULE_catchProduction          = 26
	ECMAScriptParserRULE_finallyProduction        = 27
	ECMAScriptParserRULE_debuggerStatement        = 28
	ECMAScriptParserRULE_functionDeclaration      = 29
	ECMAScriptParserRULE_formalParameterList      = 30
	ECMAScriptParserRULE_functionBody             = 31
	ECMAScriptParserRULE_arrayLiteral             = 32
	ECMAScriptParserRULE_elementList              = 33
	ECMAScriptParserRULE_elision                  = 34
	ECMAScriptParserRULE_objectLiteral            = 35
	ECMAScriptParserRULE_propertyNameAndValueList = 36
	ECMAScriptParserRULE_propertyAssignment       = 37
	ECMAScriptParserRULE_propertyName             = 38
	ECMAScriptParserRULE_propertySetParameterList = 39
	ECMAScriptParserRULE_arguments                = 40
	ECMAScriptParserRULE_argumentList             = 41
	ECMAScriptParserRULE_expressionSequence       = 42
	ECMAScriptParserRULE_singleExpression         = 43
	ECMAScriptParserRULE_assignmentOperator       = 44
	ECMAScriptParserRULE_literal                  = 45
	ECMAScriptParserRULE_numericLiteral           = 46
	ECMAScriptParserRULE_identifierName           = 47
	ECMAScriptParserRULE_reservedWord             = 48
	ECMAScriptParserRULE_keyword                  = 49
	ECMAScriptParserRULE_futureReservedWord       = 50
	ECMAScriptParserRULE_getter                   = 51
	ECMAScriptParserRULE_setter                   = 52
	ECMAScriptParserRULE_eos                      = 53
	ECMAScriptParserRULE_eof                      = 54
)

ECMAScriptParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdditiveExpressionContext 

type AdditiveExpressionContext struct {
	*SingleExpressionContext
}

func NewAdditiveExpressionContext 

func NewAdditiveExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdditiveExpressionContext

func (*AdditiveExpressionContext) AllSingleExpression 

func (s *AdditiveExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AdditiveExpressionContext) EnterRule 

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

func (*AdditiveExpressionContext) ExitRule 

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

func (*AdditiveExpressionContext) GetRuleContext 

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

func (*AdditiveExpressionContext) Minus 

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

func (*AdditiveExpressionContext) Plus 

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

func (*AdditiveExpressionContext) SingleExpression 

func (s *AdditiveExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ArgumentListContext 

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

func NewArgumentListContext 

func NewArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentListContext

func NewEmptyArgumentListContext 

func NewEmptyArgumentListContext() *ArgumentListContext

func (*ArgumentListContext) AllComma 

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

func (*ArgumentListContext) AllSingleExpression 

func (s *ArgumentListContext) AllSingleExpression() []ISingleExpressionContext

func (*ArgumentListContext) Comma 

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

func (*ArgumentListContext) EnterRule 

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

func (*ArgumentListContext) ExitRule 

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

func (*ArgumentListContext) GetParser 

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

func (*ArgumentListContext) GetRuleContext 

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

func (*ArgumentListContext) IsArgumentListContext 

func (*ArgumentListContext) IsArgumentListContext()

func (*ArgumentListContext) SingleExpression 

func (s *ArgumentListContext) SingleExpression(i int) ISingleExpressionContext

func (*ArgumentListContext) ToStringTree 

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

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

func (s *ArgumentsContext) ArgumentList() IArgumentListContext

func (*ArgumentsContext) CloseParen 

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

func (*ArgumentsContext) EnterRule 

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

func (*ArgumentsContext) ExitRule 

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

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 ArgumentsExpressionContext 

type ArgumentsExpressionContext struct {
	*SingleExpressionContext
}

func NewArgumentsExpressionContext 

func NewArgumentsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArgumentsExpressionContext

func (*ArgumentsExpressionContext) Arguments 

func (s *ArgumentsExpressionContext) Arguments() IArgumentsContext

func (*ArgumentsExpressionContext) EnterRule 

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

func (*ArgumentsExpressionContext) ExitRule 

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

func (*ArgumentsExpressionContext) GetRuleContext 

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

func (*ArgumentsExpressionContext) SingleExpression 

func (s *ArgumentsExpressionContext) SingleExpression() ISingleExpressionContext

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

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

func (*ArrayLiteralContext) Comma 

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

func (*ArrayLiteralContext) ElementList 

func (s *ArrayLiteralContext) ElementList() IElementListContext

func (*ArrayLiteralContext) Elision 

func (s *ArrayLiteralContext) Elision() IElisionContext

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 ArrayLiteralExpressionContext 

type ArrayLiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewArrayLiteralExpressionContext 

func NewArrayLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLiteralExpressionContext

func (*ArrayLiteralExpressionContext) ArrayLiteral 

func (s *ArrayLiteralExpressionContext) ArrayLiteral() IArrayLiteralContext

func (*ArrayLiteralExpressionContext) EnterRule 

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

func (*ArrayLiteralExpressionContext) ExitRule 

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

func (*ArrayLiteralExpressionContext) GetRuleContext 

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

type AssignmentExpressionContext 

type AssignmentExpressionContext struct {
	*SingleExpressionContext
}

func NewAssignmentExpressionContext 

func NewAssignmentExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentExpressionContext

func (*AssignmentExpressionContext) AllSingleExpression 

func (s *AssignmentExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AssignmentExpressionContext) Assign 

func (s *AssignmentExpressionContext) Assign() antlr.TerminalNode

func (*AssignmentExpressionContext) EnterRule 

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

func (*AssignmentExpressionContext) ExitRule 

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

func (*AssignmentExpressionContext) GetRuleContext 

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

func (*AssignmentExpressionContext) SingleExpression 

func (s *AssignmentExpressionContext) SingleExpression(i int) ISingleExpressionContext

type AssignmentOperatorContext 

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

func NewAssignmentOperatorContext 

func NewAssignmentOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentOperatorContext

func NewEmptyAssignmentOperatorContext 

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext

func (*AssignmentOperatorContext) BitAndAssign 

func (s *AssignmentOperatorContext) BitAndAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) BitOrAssign 

func (s *AssignmentOperatorContext) BitOrAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) BitXorAssign 

func (s *AssignmentOperatorContext) BitXorAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) DivideAssign 

func (s *AssignmentOperatorContext) DivideAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) EnterRule 

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

func (*AssignmentOperatorContext) ExitRule 

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

func (*AssignmentOperatorContext) GetParser 

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

func (*AssignmentOperatorContext) GetRuleContext 

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

func (*AssignmentOperatorContext) IsAssignmentOperatorContext 

func (*AssignmentOperatorContext) IsAssignmentOperatorContext()

func (*AssignmentOperatorContext) LeftShiftArithmeticAssign 

func (s *AssignmentOperatorContext) LeftShiftArithmeticAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) MinusAssign 

func (s *AssignmentOperatorContext) MinusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) ModulusAssign 

func (s *AssignmentOperatorContext) ModulusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) MultiplyAssign 

func (s *AssignmentOperatorContext) MultiplyAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) PlusAssign 

func (s *AssignmentOperatorContext) PlusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) RightShiftArithmeticAssign 

func (s *AssignmentOperatorContext) RightShiftArithmeticAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) RightShiftLogicalAssign 

func (s *AssignmentOperatorContext) RightShiftLogicalAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) ToStringTree 

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

type AssignmentOperatorExpressionContext 

type AssignmentOperatorExpressionContext struct {
	*SingleExpressionContext
}

func NewAssignmentOperatorExpressionContext 

func NewAssignmentOperatorExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentOperatorExpressionContext

func (*AssignmentOperatorExpressionContext) AllSingleExpression 

func (s *AssignmentOperatorExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AssignmentOperatorExpressionContext) AssignmentOperator 

func (s *AssignmentOperatorExpressionContext) AssignmentOperator() IAssignmentOperatorContext

func (*AssignmentOperatorExpressionContext) EnterRule 

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

func (*AssignmentOperatorExpressionContext) ExitRule 

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

func (*AssignmentOperatorExpressionContext) GetRuleContext 

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

func (*AssignmentOperatorExpressionContext) SingleExpression 

func (s *AssignmentOperatorExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BaseECMAScriptListener 

type BaseECMAScriptListener struct{}

BaseECMAScriptListener is a complete listener for a parse tree produced by ECMAScriptParser.

func (*BaseECMAScriptListener) EnterAdditiveExpression 

func (s *BaseECMAScriptListener) EnterAdditiveExpression(ctx *AdditiveExpressionContext)

EnterAdditiveExpression is called when production AdditiveExpression is entered.

func (*BaseECMAScriptListener) EnterArgumentList 

func (s *BaseECMAScriptListener) EnterArgumentList(ctx *ArgumentListContext)

EnterArgumentList is called when production argumentList is entered.

func (*BaseECMAScriptListener) EnterArguments 

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

EnterArguments is called when production arguments is entered.

func (*BaseECMAScriptListener) EnterArgumentsExpression 

func (s *BaseECMAScriptListener) EnterArgumentsExpression(ctx *ArgumentsExpressionContext)

EnterArgumentsExpression is called when production ArgumentsExpression is entered.

func (*BaseECMAScriptListener) EnterArrayLiteral 

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

EnterArrayLiteral is called when production arrayLiteral is entered.

func (*BaseECMAScriptListener) EnterArrayLiteralExpression 

func (s *BaseECMAScriptListener) EnterArrayLiteralExpression(ctx *ArrayLiteralExpressionContext)

EnterArrayLiteralExpression is called when production ArrayLiteralExpression is entered.

func (*BaseECMAScriptListener) EnterAssignmentExpression 

func (s *BaseECMAScriptListener) EnterAssignmentExpression(ctx *AssignmentExpressionContext)

EnterAssignmentExpression is called when production AssignmentExpression is entered.

func (*BaseECMAScriptListener) EnterAssignmentOperator 

func (s *BaseECMAScriptListener) EnterAssignmentOperator(ctx *AssignmentOperatorContext)

EnterAssignmentOperator is called when production assignmentOperator is entered.

func (*BaseECMAScriptListener) EnterAssignmentOperatorExpression 

func (s *BaseECMAScriptListener) EnterAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext)

EnterAssignmentOperatorExpression is called when production AssignmentOperatorExpression is entered.

func (*BaseECMAScriptListener) EnterBitAndExpression 

func (s *BaseECMAScriptListener) EnterBitAndExpression(ctx *BitAndExpressionContext)

EnterBitAndExpression is called when production BitAndExpression is entered.

func (*BaseECMAScriptListener) EnterBitNotExpression 

func (s *BaseECMAScriptListener) EnterBitNotExpression(ctx *BitNotExpressionContext)

EnterBitNotExpression is called when production BitNotExpression is entered.

func (*BaseECMAScriptListener) EnterBitOrExpression 

func (s *BaseECMAScriptListener) EnterBitOrExpression(ctx *BitOrExpressionContext)

EnterBitOrExpression is called when production BitOrExpression is entered.

func (*BaseECMAScriptListener) EnterBitShiftExpression 

func (s *BaseECMAScriptListener) EnterBitShiftExpression(ctx *BitShiftExpressionContext)

EnterBitShiftExpression is called when production BitShiftExpression is entered.

func (*BaseECMAScriptListener) EnterBitXOrExpression 

func (s *BaseECMAScriptListener) EnterBitXOrExpression(ctx *BitXOrExpressionContext)

EnterBitXOrExpression is called when production BitXOrExpression is entered.

func (*BaseECMAScriptListener) EnterBlock 

func (s *BaseECMAScriptListener) EnterBlock(ctx *BlockContext)

EnterBlock is called when production block is entered.

func (*BaseECMAScriptListener) EnterBreakStatement 

func (s *BaseECMAScriptListener) EnterBreakStatement(ctx *BreakStatementContext)

EnterBreakStatement is called when production breakStatement is entered.

func (*BaseECMAScriptListener) EnterCaseBlock 

func (s *BaseECMAScriptListener) EnterCaseBlock(ctx *CaseBlockContext)

EnterCaseBlock is called when production caseBlock is entered.

func (*BaseECMAScriptListener) EnterCaseClause 

func (s *BaseECMAScriptListener) EnterCaseClause(ctx *CaseClauseContext)

EnterCaseClause is called when production caseClause is entered.

func (*BaseECMAScriptListener) EnterCaseClauses 

func (s *BaseECMAScriptListener) EnterCaseClauses(ctx *CaseClausesContext)

EnterCaseClauses is called when production caseClauses is entered.

func (*BaseECMAScriptListener) EnterCatchProduction 

func (s *BaseECMAScriptListener) EnterCatchProduction(ctx *CatchProductionContext)

EnterCatchProduction is called when production catchProduction is entered.

func (*BaseECMAScriptListener) EnterContinueStatement 

func (s *BaseECMAScriptListener) EnterContinueStatement(ctx *ContinueStatementContext)

EnterContinueStatement is called when production continueStatement is entered.

func (*BaseECMAScriptListener) EnterDebuggerStatement 

func (s *BaseECMAScriptListener) EnterDebuggerStatement(ctx *DebuggerStatementContext)

EnterDebuggerStatement is called when production debuggerStatement is entered.

func (*BaseECMAScriptListener) EnterDefaultClause 

func (s *BaseECMAScriptListener) EnterDefaultClause(ctx *DefaultClauseContext)

EnterDefaultClause is called when production defaultClause is entered.

func (*BaseECMAScriptListener) EnterDeleteExpression 

func (s *BaseECMAScriptListener) EnterDeleteExpression(ctx *DeleteExpressionContext)

EnterDeleteExpression is called when production DeleteExpression is entered.

func (*BaseECMAScriptListener) EnterDoStatement 

func (s *BaseECMAScriptListener) EnterDoStatement(ctx *DoStatementContext)

EnterDoStatement is called when production DoStatement is entered.

func (*BaseECMAScriptListener) EnterElementList 

func (s *BaseECMAScriptListener) EnterElementList(ctx *ElementListContext)

EnterElementList is called when production elementList is entered.

func (*BaseECMAScriptListener) EnterElision 

func (s *BaseECMAScriptListener) EnterElision(ctx *ElisionContext)

EnterElision is called when production elision is entered.

func (*BaseECMAScriptListener) EnterEof 

func (s *BaseECMAScriptListener) EnterEof(ctx *EofContext)

EnterEof is called when production eof is entered.

func (*BaseECMAScriptListener) EnterEos 

func (s *BaseECMAScriptListener) EnterEos(ctx *EosContext)

EnterEos is called when production eos is entered.

func (*BaseECMAScriptListener) EnterEqualityExpression 

func (s *BaseECMAScriptListener) EnterEqualityExpression(ctx *EqualityExpressionContext)

EnterEqualityExpression is called when production EqualityExpression is entered.

func (*BaseECMAScriptListener) EnterEveryRule 

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

EnterEveryRule is called when any rule is entered.

func (*BaseECMAScriptListener) EnterExpressionSequence 

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

EnterExpressionSequence is called when production expressionSequence is entered.

func (*BaseECMAScriptListener) EnterExpressionStatement 

func (s *BaseECMAScriptListener) EnterExpressionStatement(ctx *ExpressionStatementContext)

EnterExpressionStatement is called when production expressionStatement is entered.

func (*BaseECMAScriptListener) EnterFinallyProduction 

func (s *BaseECMAScriptListener) EnterFinallyProduction(ctx *FinallyProductionContext)

EnterFinallyProduction is called when production finallyProduction is entered.

func (*BaseECMAScriptListener) EnterForInStatement 

func (s *BaseECMAScriptListener) EnterForInStatement(ctx *ForInStatementContext)

EnterForInStatement is called when production ForInStatement is entered.

func (*BaseECMAScriptListener) EnterForStatement 

func (s *BaseECMAScriptListener) EnterForStatement(ctx *ForStatementContext)

EnterForStatement is called when production ForStatement is entered.

func (*BaseECMAScriptListener) EnterForVarInStatement 

func (s *BaseECMAScriptListener) EnterForVarInStatement(ctx *ForVarInStatementContext)

EnterForVarInStatement is called when production ForVarInStatement is entered.

func (*BaseECMAScriptListener) EnterForVarStatement 

func (s *BaseECMAScriptListener) EnterForVarStatement(ctx *ForVarStatementContext)

EnterForVarStatement is called when production ForVarStatement is entered.

func (*BaseECMAScriptListener) EnterFormalParameterList 

func (s *BaseECMAScriptListener) EnterFormalParameterList(ctx *FormalParameterListContext)

EnterFormalParameterList is called when production formalParameterList is entered.

func (*BaseECMAScriptListener) EnterFunctionBody 

func (s *BaseECMAScriptListener) EnterFunctionBody(ctx *FunctionBodyContext)

EnterFunctionBody is called when production functionBody is entered.

func (*BaseECMAScriptListener) EnterFunctionDeclaration 

func (s *BaseECMAScriptListener) EnterFunctionDeclaration(ctx *FunctionDeclarationContext)

EnterFunctionDeclaration is called when production functionDeclaration is entered.

func (*BaseECMAScriptListener) EnterFunctionExpression 

func (s *BaseECMAScriptListener) EnterFunctionExpression(ctx *FunctionExpressionContext)

EnterFunctionExpression is called when production FunctionExpression is entered.

func (*BaseECMAScriptListener) EnterFutureReservedWord 

func (s *BaseECMAScriptListener) EnterFutureReservedWord(ctx *FutureReservedWordContext)

EnterFutureReservedWord is called when production futureReservedWord is entered.

func (*BaseECMAScriptListener) EnterGetter 

func (s *BaseECMAScriptListener) EnterGetter(ctx *GetterContext)

EnterGetter is called when production getter is entered.

func (*BaseECMAScriptListener) EnterIdentifierExpression 

func (s *BaseECMAScriptListener) EnterIdentifierExpression(ctx *IdentifierExpressionContext)

EnterIdentifierExpression is called when production IdentifierExpression is entered.

func (*BaseECMAScriptListener) EnterIdentifierName 

func (s *BaseECMAScriptListener) EnterIdentifierName(ctx *IdentifierNameContext)

EnterIdentifierName is called when production identifierName is entered.

func (*BaseECMAScriptListener) EnterIfStatement 

func (s *BaseECMAScriptListener) EnterIfStatement(ctx *IfStatementContext)

EnterIfStatement is called when production ifStatement is entered.

func (*BaseECMAScriptListener) EnterInExpression 

func (s *BaseECMAScriptListener) EnterInExpression(ctx *InExpressionContext)

EnterInExpression is called when production InExpression is entered.

func (*BaseECMAScriptListener) EnterInitialiser 

func (s *BaseECMAScriptListener) EnterInitialiser(ctx *InitialiserContext)

EnterInitialiser is called when production initialiser is entered.

func (*BaseECMAScriptListener) EnterInstanceofExpression 

func (s *BaseECMAScriptListener) EnterInstanceofExpression(ctx *InstanceofExpressionContext)

EnterInstanceofExpression is called when production InstanceofExpression is entered.

func (*BaseECMAScriptListener) EnterKeyword 

func (s *BaseECMAScriptListener) EnterKeyword(ctx *KeywordContext)

EnterKeyword is called when production keyword is entered.

func (*BaseECMAScriptListener) EnterLabelledStatement 

func (s *BaseECMAScriptListener) EnterLabelledStatement(ctx *LabelledStatementContext)

EnterLabelledStatement is called when production labelledStatement is entered.

func (*BaseECMAScriptListener) EnterLiteral 

func (s *BaseECMAScriptListener) EnterLiteral(ctx *LiteralContext)

EnterLiteral is called when production literal is entered.

func (*BaseECMAScriptListener) EnterLiteralExpression 

func (s *BaseECMAScriptListener) EnterLiteralExpression(ctx *LiteralExpressionContext)

EnterLiteralExpression is called when production LiteralExpression is entered.

func (*BaseECMAScriptListener) EnterLogicalAndExpression 

func (s *BaseECMAScriptListener) EnterLogicalAndExpression(ctx *LogicalAndExpressionContext)

EnterLogicalAndExpression is called when production LogicalAndExpression is entered.

func (*BaseECMAScriptListener) EnterLogicalOrExpression 

func (s *BaseECMAScriptListener) EnterLogicalOrExpression(ctx *LogicalOrExpressionContext)

EnterLogicalOrExpression is called when production LogicalOrExpression is entered.

func (*BaseECMAScriptListener) EnterMemberDotExpression 

func (s *BaseECMAScriptListener) EnterMemberDotExpression(ctx *MemberDotExpressionContext)

EnterMemberDotExpression is called when production MemberDotExpression is entered.

func (*BaseECMAScriptListener) EnterMemberIndexExpression 

func (s *BaseECMAScriptListener) EnterMemberIndexExpression(ctx *MemberIndexExpressionContext)

EnterMemberIndexExpression is called when production MemberIndexExpression is entered.

func (*BaseECMAScriptListener) EnterMultiplicativeExpression 

func (s *BaseECMAScriptListener) EnterMultiplicativeExpression(ctx *MultiplicativeExpressionContext)

EnterMultiplicativeExpression is called when production MultiplicativeExpression is entered.

func (*BaseECMAScriptListener) EnterNewExpression 

func (s *BaseECMAScriptListener) EnterNewExpression(ctx *NewExpressionContext)

EnterNewExpression is called when production NewExpression is entered.

func (*BaseECMAScriptListener) EnterNotExpression 

func (s *BaseECMAScriptListener) EnterNotExpression(ctx *NotExpressionContext)

EnterNotExpression is called when production NotExpression is entered.

func (*BaseECMAScriptListener) EnterNumericLiteral 

func (s *BaseECMAScriptListener) EnterNumericLiteral(ctx *NumericLiteralContext)

EnterNumericLiteral is called when production numericLiteral is entered.

func (*BaseECMAScriptListener) EnterObjectLiteral 

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

EnterObjectLiteral is called when production objectLiteral is entered.

func (*BaseECMAScriptListener) EnterObjectLiteralExpression 

func (s *BaseECMAScriptListener) EnterObjectLiteralExpression(ctx *ObjectLiteralExpressionContext)

EnterObjectLiteralExpression is called when production ObjectLiteralExpression is entered.

func (*BaseECMAScriptListener) EnterParenthesizedExpression 

func (s *BaseECMAScriptListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext)

EnterParenthesizedExpression is called when production ParenthesizedExpression is entered.

func (*BaseECMAScriptListener) EnterPostDecreaseExpression 

func (s *BaseECMAScriptListener) EnterPostDecreaseExpression(ctx *PostDecreaseExpressionContext)

EnterPostDecreaseExpression is called when production PostDecreaseExpression is entered.

func (*BaseECMAScriptListener) EnterPostIncrementExpression 

func (s *BaseECMAScriptListener) EnterPostIncrementExpression(ctx *PostIncrementExpressionContext)

EnterPostIncrementExpression is called when production PostIncrementExpression is entered.

func (*BaseECMAScriptListener) EnterPreDecreaseExpression 

func (s *BaseECMAScriptListener) EnterPreDecreaseExpression(ctx *PreDecreaseExpressionContext)

EnterPreDecreaseExpression is called when production PreDecreaseExpression is entered.

func (*BaseECMAScriptListener) EnterPreIncrementExpression 

func (s *BaseECMAScriptListener) EnterPreIncrementExpression(ctx *PreIncrementExpressionContext)

EnterPreIncrementExpression is called when production PreIncrementExpression is entered.

func (*BaseECMAScriptListener) EnterProgram 

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

EnterProgram is called when production program is entered.

func (*BaseECMAScriptListener) EnterPropertyExpressionAssignment 

func (s *BaseECMAScriptListener) EnterPropertyExpressionAssignment(ctx *PropertyExpressionAssignmentContext)

EnterPropertyExpressionAssignment is called when production PropertyExpressionAssignment is entered.

func (*BaseECMAScriptListener) EnterPropertyGetter 

func (s *BaseECMAScriptListener) EnterPropertyGetter(ctx *PropertyGetterContext)

EnterPropertyGetter is called when production PropertyGetter is entered.

func (*BaseECMAScriptListener) EnterPropertyName 

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

EnterPropertyName is called when production propertyName is entered.

func (*BaseECMAScriptListener) EnterPropertyNameAndValueList 

func (s *BaseECMAScriptListener) EnterPropertyNameAndValueList(ctx *PropertyNameAndValueListContext)

EnterPropertyNameAndValueList is called when production propertyNameAndValueList is entered.

func (*BaseECMAScriptListener) EnterPropertySetParameterList 

func (s *BaseECMAScriptListener) EnterPropertySetParameterList(ctx *PropertySetParameterListContext)

EnterPropertySetParameterList is called when production propertySetParameterList is entered.

func (*BaseECMAScriptListener) EnterPropertySetter 

func (s *BaseECMAScriptListener) EnterPropertySetter(ctx *PropertySetterContext)

EnterPropertySetter is called when production PropertySetter is entered.

func (*BaseECMAScriptListener) EnterRelationalExpression 

func (s *BaseECMAScriptListener) EnterRelationalExpression(ctx *RelationalExpressionContext)

EnterRelationalExpression is called when production RelationalExpression is entered.

func (*BaseECMAScriptListener) EnterReservedWord 

func (s *BaseECMAScriptListener) EnterReservedWord(ctx *ReservedWordContext)

EnterReservedWord is called when production reservedWord is entered.

func (*BaseECMAScriptListener) EnterReturnStatement 

func (s *BaseECMAScriptListener) EnterReturnStatement(ctx *ReturnStatementContext)

EnterReturnStatement is called when production returnStatement is entered.

func (*BaseECMAScriptListener) EnterSetter 

func (s *BaseECMAScriptListener) EnterSetter(ctx *SetterContext)

EnterSetter is called when production setter is entered.

func (*BaseECMAScriptListener) EnterSourceElement 

func (s *BaseECMAScriptListener) EnterSourceElement(ctx *SourceElementContext)

EnterSourceElement is called when production sourceElement is entered.

func (*BaseECMAScriptListener) EnterSourceElements 

func (s *BaseECMAScriptListener) EnterSourceElements(ctx *SourceElementsContext)

EnterSourceElements is called when production sourceElements is entered.

func (*BaseECMAScriptListener) EnterStatement 

func (s *BaseECMAScriptListener) EnterStatement(ctx *StatementContext)

EnterStatement is called when production statement is entered.

func (*BaseECMAScriptListener) EnterStatementList 

func (s *BaseECMAScriptListener) EnterStatementList(ctx *StatementListContext)

EnterStatementList is called when production statementList is entered.

func (*BaseECMAScriptListener) EnterSwitchStatement 

func (s *BaseECMAScriptListener) EnterSwitchStatement(ctx *SwitchStatementContext)

EnterSwitchStatement is called when production switchStatement is entered.

func (*BaseECMAScriptListener) EnterTernaryExpression 

func (s *BaseECMAScriptListener) EnterTernaryExpression(ctx *TernaryExpressionContext)

EnterTernaryExpression is called when production TernaryExpression is entered.

func (*BaseECMAScriptListener) EnterThisExpression 

func (s *BaseECMAScriptListener) EnterThisExpression(ctx *ThisExpressionContext)

EnterThisExpression is called when production ThisExpression is entered.

func (*BaseECMAScriptListener) EnterThrowStatement 

func (s *BaseECMAScriptListener) EnterThrowStatement(ctx *ThrowStatementContext)

EnterThrowStatement is called when production throwStatement is entered.

func (*BaseECMAScriptListener) EnterTryStatement 

func (s *BaseECMAScriptListener) EnterTryStatement(ctx *TryStatementContext)

EnterTryStatement is called when production tryStatement is entered.

func (*BaseECMAScriptListener) EnterTypeofExpression 

func (s *BaseECMAScriptListener) EnterTypeofExpression(ctx *TypeofExpressionContext)

EnterTypeofExpression is called when production TypeofExpression is entered.

func (*BaseECMAScriptListener) EnterUnaryMinusExpression 

func (s *BaseECMAScriptListener) EnterUnaryMinusExpression(ctx *UnaryMinusExpressionContext)

EnterUnaryMinusExpression is called when production UnaryMinusExpression is entered.

func (*BaseECMAScriptListener) EnterUnaryPlusExpression 

func (s *BaseECMAScriptListener) EnterUnaryPlusExpression(ctx *UnaryPlusExpressionContext)

EnterUnaryPlusExpression is called when production UnaryPlusExpression is entered.

func (*BaseECMAScriptListener) EnterVariableDeclaration 

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

EnterVariableDeclaration is called when production variableDeclaration is entered.

func (*BaseECMAScriptListener) EnterVariableDeclarationList 

func (s *BaseECMAScriptListener) EnterVariableDeclarationList(ctx *VariableDeclarationListContext)

EnterVariableDeclarationList is called when production variableDeclarationList is entered.

func (*BaseECMAScriptListener) EnterVariableStatement 

func (s *BaseECMAScriptListener) EnterVariableStatement(ctx *VariableStatementContext)

EnterVariableStatement is called when production variableStatement is entered.

func (*BaseECMAScriptListener) EnterVoidExpression 

func (s *BaseECMAScriptListener) EnterVoidExpression(ctx *VoidExpressionContext)

EnterVoidExpression is called when production VoidExpression is entered.

func (*BaseECMAScriptListener) EnterVoidStatement 

func (s *BaseECMAScriptListener) EnterVoidStatement(ctx *VoidStatementContext)

EnterVoidStatement is called when production voidStatement is entered.

func (*BaseECMAScriptListener) EnterWhileStatement 

func (s *BaseECMAScriptListener) EnterWhileStatement(ctx *WhileStatementContext)

EnterWhileStatement is called when production WhileStatement is entered.

func (*BaseECMAScriptListener) EnterWithStatement 

func (s *BaseECMAScriptListener) EnterWithStatement(ctx *WithStatementContext)

EnterWithStatement is called when production withStatement is entered.

func (*BaseECMAScriptListener) ExitAdditiveExpression 

func (s *BaseECMAScriptListener) ExitAdditiveExpression(ctx *AdditiveExpressionContext)

ExitAdditiveExpression is called when production AdditiveExpression is exited.

func (*BaseECMAScriptListener) ExitArgumentList 

func (s *BaseECMAScriptListener) ExitArgumentList(ctx *ArgumentListContext)

ExitArgumentList is called when production argumentList is exited.

func (*BaseECMAScriptListener) ExitArguments 

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

ExitArguments is called when production arguments is exited.

func (*BaseECMAScriptListener) ExitArgumentsExpression 

func (s *BaseECMAScriptListener) ExitArgumentsExpression(ctx *ArgumentsExpressionContext)

ExitArgumentsExpression is called when production ArgumentsExpression is exited.

func (*BaseECMAScriptListener) ExitArrayLiteral 

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

ExitArrayLiteral is called when production arrayLiteral is exited.

func (*BaseECMAScriptListener) ExitArrayLiteralExpression 

func (s *BaseECMAScriptListener) ExitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext)

ExitArrayLiteralExpression is called when production ArrayLiteralExpression is exited.

func (*BaseECMAScriptListener) ExitAssignmentExpression 

func (s *BaseECMAScriptListener) ExitAssignmentExpression(ctx *AssignmentExpressionContext)

ExitAssignmentExpression is called when production AssignmentExpression is exited.

func (*BaseECMAScriptListener) ExitAssignmentOperator 

func (s *BaseECMAScriptListener) ExitAssignmentOperator(ctx *AssignmentOperatorContext)

ExitAssignmentOperator is called when production assignmentOperator is exited.

func (*BaseECMAScriptListener) ExitAssignmentOperatorExpression 

func (s *BaseECMAScriptListener) ExitAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext)

ExitAssignmentOperatorExpression is called when production AssignmentOperatorExpression is exited.

func (*BaseECMAScriptListener) ExitBitAndExpression 

func (s *BaseECMAScriptListener) ExitBitAndExpression(ctx *BitAndExpressionContext)

ExitBitAndExpression is called when production BitAndExpression is exited.

func (*BaseECMAScriptListener) ExitBitNotExpression 

func (s *BaseECMAScriptListener) ExitBitNotExpression(ctx *BitNotExpressionContext)

ExitBitNotExpression is called when production BitNotExpression is exited.

func (*BaseECMAScriptListener) ExitBitOrExpression 

func (s *BaseECMAScriptListener) ExitBitOrExpression(ctx *BitOrExpressionContext)

ExitBitOrExpression is called when production BitOrExpression is exited.

func (*BaseECMAScriptListener) ExitBitShiftExpression 

func (s *BaseECMAScriptListener) ExitBitShiftExpression(ctx *BitShiftExpressionContext)

ExitBitShiftExpression is called when production BitShiftExpression is exited.

func (*BaseECMAScriptListener) ExitBitXOrExpression 

func (s *BaseECMAScriptListener) ExitBitXOrExpression(ctx *BitXOrExpressionContext)

ExitBitXOrExpression is called when production BitXOrExpression is exited.

func (*BaseECMAScriptListener) ExitBlock 

func (s *BaseECMAScriptListener) ExitBlock(ctx *BlockContext)

ExitBlock is called when production block is exited.

func (*BaseECMAScriptListener) ExitBreakStatement 

func (s *BaseECMAScriptListener) ExitBreakStatement(ctx *BreakStatementContext)

ExitBreakStatement is called when production breakStatement is exited.

func (*BaseECMAScriptListener) ExitCaseBlock 

func (s *BaseECMAScriptListener) ExitCaseBlock(ctx *CaseBlockContext)

ExitCaseBlock is called when production caseBlock is exited.

func (*BaseECMAScriptListener) ExitCaseClause 

func (s *BaseECMAScriptListener) ExitCaseClause(ctx *CaseClauseContext)

ExitCaseClause is called when production caseClause is exited.

func (*BaseECMAScriptListener) ExitCaseClauses 

func (s *BaseECMAScriptListener) ExitCaseClauses(ctx *CaseClausesContext)

ExitCaseClauses is called when production caseClauses is exited.

func (*BaseECMAScriptListener) ExitCatchProduction 

func (s *BaseECMAScriptListener) ExitCatchProduction(ctx *CatchProductionContext)

ExitCatchProduction is called when production catchProduction is exited.

func (*BaseECMAScriptListener) ExitContinueStatement 

func (s *BaseECMAScriptListener) ExitContinueStatement(ctx *ContinueStatementContext)

ExitContinueStatement is called when production continueStatement is exited.

func (*BaseECMAScriptListener) ExitDebuggerStatement 

func (s *BaseECMAScriptListener) ExitDebuggerStatement(ctx *DebuggerStatementContext)

ExitDebuggerStatement is called when production debuggerStatement is exited.

func (*BaseECMAScriptListener) ExitDefaultClause 

func (s *BaseECMAScriptListener) ExitDefaultClause(ctx *DefaultClauseContext)

ExitDefaultClause is called when production defaultClause is exited.

func (*BaseECMAScriptListener) ExitDeleteExpression 

func (s *BaseECMAScriptListener) ExitDeleteExpression(ctx *DeleteExpressionContext)

ExitDeleteExpression is called when production DeleteExpression is exited.

func (*BaseECMAScriptListener) ExitDoStatement 

func (s *BaseECMAScriptListener) ExitDoStatement(ctx *DoStatementContext)

ExitDoStatement is called when production DoStatement is exited.

func (*BaseECMAScriptListener) ExitElementList 

func (s *BaseECMAScriptListener) ExitElementList(ctx *ElementListContext)

ExitElementList is called when production elementList is exited.

func (*BaseECMAScriptListener) ExitElision 

func (s *BaseECMAScriptListener) ExitElision(ctx *ElisionContext)

ExitElision is called when production elision is exited.

func (*BaseECMAScriptListener) ExitEof 

func (s *BaseECMAScriptListener) ExitEof(ctx *EofContext)

ExitEof is called when production eof is exited.

func (*BaseECMAScriptListener) ExitEos 

func (s *BaseECMAScriptListener) ExitEos(ctx *EosContext)

ExitEos is called when production eos is exited.

func (*BaseECMAScriptListener) ExitEqualityExpression 

func (s *BaseECMAScriptListener) ExitEqualityExpression(ctx *EqualityExpressionContext)

ExitEqualityExpression is called when production EqualityExpression is exited.

func (*BaseECMAScriptListener) ExitEveryRule 

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

ExitEveryRule is called when any rule is exited.

func (*BaseECMAScriptListener) ExitExpressionSequence 

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

ExitExpressionSequence is called when production expressionSequence is exited.

func (*BaseECMAScriptListener) ExitExpressionStatement 

func (s *BaseECMAScriptListener) ExitExpressionStatement(ctx *ExpressionStatementContext)

ExitExpressionStatement is called when production expressionStatement is exited.

func (*BaseECMAScriptListener) ExitFinallyProduction 

func (s *BaseECMAScriptListener) ExitFinallyProduction(ctx *FinallyProductionContext)

ExitFinallyProduction is called when production finallyProduction is exited.

func (*BaseECMAScriptListener) ExitForInStatement 

func (s *BaseECMAScriptListener) ExitForInStatement(ctx *ForInStatementContext)

ExitForInStatement is called when production ForInStatement is exited.

func (*BaseECMAScriptListener) ExitForStatement 

func (s *BaseECMAScriptListener) ExitForStatement(ctx *ForStatementContext)

ExitForStatement is called when production ForStatement is exited.

func (*BaseECMAScriptListener) ExitForVarInStatement 

func (s *BaseECMAScriptListener) ExitForVarInStatement(ctx *ForVarInStatementContext)

ExitForVarInStatement is called when production ForVarInStatement is exited.

func (*BaseECMAScriptListener) ExitForVarStatement 

func (s *BaseECMAScriptListener) ExitForVarStatement(ctx *ForVarStatementContext)

ExitForVarStatement is called when production ForVarStatement is exited.

func (*BaseECMAScriptListener) ExitFormalParameterList 

func (s *BaseECMAScriptListener) ExitFormalParameterList(ctx *FormalParameterListContext)

ExitFormalParameterList is called when production formalParameterList is exited.

func (*BaseECMAScriptListener) ExitFunctionBody 

func (s *BaseECMAScriptListener) ExitFunctionBody(ctx *FunctionBodyContext)

ExitFunctionBody is called when production functionBody is exited.

func (*BaseECMAScriptListener) ExitFunctionDeclaration 

func (s *BaseECMAScriptListener) ExitFunctionDeclaration(ctx *FunctionDeclarationContext)

ExitFunctionDeclaration is called when production functionDeclaration is exited.

func (*BaseECMAScriptListener) ExitFunctionExpression 

func (s *BaseECMAScriptListener) ExitFunctionExpression(ctx *FunctionExpressionContext)

ExitFunctionExpression is called when production FunctionExpression is exited.

func (*BaseECMAScriptListener) ExitFutureReservedWord 

func (s *BaseECMAScriptListener) ExitFutureReservedWord(ctx *FutureReservedWordContext)

ExitFutureReservedWord is called when production futureReservedWord is exited.

func (*BaseECMAScriptListener) ExitGetter 

func (s *BaseECMAScriptListener) ExitGetter(ctx *GetterContext)

ExitGetter is called when production getter is exited.

func (*BaseECMAScriptListener) ExitIdentifierExpression 

func (s *BaseECMAScriptListener) ExitIdentifierExpression(ctx *IdentifierExpressionContext)

ExitIdentifierExpression is called when production IdentifierExpression is exited.

func (*BaseECMAScriptListener) ExitIdentifierName 

func (s *BaseECMAScriptListener) ExitIdentifierName(ctx *IdentifierNameContext)

ExitIdentifierName is called when production identifierName is exited.

func (*BaseECMAScriptListener) ExitIfStatement 

func (s *BaseECMAScriptListener) ExitIfStatement(ctx *IfStatementContext)

ExitIfStatement is called when production ifStatement is exited.

func (*BaseECMAScriptListener) ExitInExpression 

func (s *BaseECMAScriptListener) ExitInExpression(ctx *InExpressionContext)

ExitInExpression is called when production InExpression is exited.

func (*BaseECMAScriptListener) ExitInitialiser 

func (s *BaseECMAScriptListener) ExitInitialiser(ctx *InitialiserContext)

ExitInitialiser is called when production initialiser is exited.

func (*BaseECMAScriptListener) ExitInstanceofExpression 

func (s *BaseECMAScriptListener) ExitInstanceofExpression(ctx *InstanceofExpressionContext)

ExitInstanceofExpression is called when production InstanceofExpression is exited.

func (*BaseECMAScriptListener) ExitKeyword 

func (s *BaseECMAScriptListener) ExitKeyword(ctx *KeywordContext)

ExitKeyword is called when production keyword is exited.

func (*BaseECMAScriptListener) ExitLabelledStatement 

func (s *BaseECMAScriptListener) ExitLabelledStatement(ctx *LabelledStatementContext)

ExitLabelledStatement is called when production labelledStatement is exited.

func (*BaseECMAScriptListener) ExitLiteral 

func (s *BaseECMAScriptListener) ExitLiteral(ctx *LiteralContext)

ExitLiteral is called when production literal is exited.

func (*BaseECMAScriptListener) ExitLiteralExpression 

func (s *BaseECMAScriptListener) ExitLiteralExpression(ctx *LiteralExpressionContext)

ExitLiteralExpression is called when production LiteralExpression is exited.

func (*BaseECMAScriptListener) ExitLogicalAndExpression 

func (s *BaseECMAScriptListener) ExitLogicalAndExpression(ctx *LogicalAndExpressionContext)

ExitLogicalAndExpression is called when production LogicalAndExpression is exited.

func (*BaseECMAScriptListener) ExitLogicalOrExpression 

func (s *BaseECMAScriptListener) ExitLogicalOrExpression(ctx *LogicalOrExpressionContext)

ExitLogicalOrExpression is called when production LogicalOrExpression is exited.

func (*BaseECMAScriptListener) ExitMemberDotExpression 

func (s *BaseECMAScriptListener) ExitMemberDotExpression(ctx *MemberDotExpressionContext)

ExitMemberDotExpression is called when production MemberDotExpression is exited.

func (*BaseECMAScriptListener) ExitMemberIndexExpression 

func (s *BaseECMAScriptListener) ExitMemberIndexExpression(ctx *MemberIndexExpressionContext)

ExitMemberIndexExpression is called when production MemberIndexExpression is exited.

func (*BaseECMAScriptListener) ExitMultiplicativeExpression 

func (s *BaseECMAScriptListener) ExitMultiplicativeExpression(ctx *MultiplicativeExpressionContext)

ExitMultiplicativeExpression is called when production MultiplicativeExpression is exited.

func (*BaseECMAScriptListener) ExitNewExpression 

func (s *BaseECMAScriptListener) ExitNewExpression(ctx *NewExpressionContext)

ExitNewExpression is called when production NewExpression is exited.

func (*BaseECMAScriptListener) ExitNotExpression 

func (s *BaseECMAScriptListener) ExitNotExpression(ctx *NotExpressionContext)

ExitNotExpression is called when production NotExpression is exited.

func (*BaseECMAScriptListener) ExitNumericLiteral 

func (s *BaseECMAScriptListener) ExitNumericLiteral(ctx *NumericLiteralContext)

ExitNumericLiteral is called when production numericLiteral is exited.

func (*BaseECMAScriptListener) ExitObjectLiteral 

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

ExitObjectLiteral is called when production objectLiteral is exited.

func (*BaseECMAScriptListener) ExitObjectLiteralExpression 

func (s *BaseECMAScriptListener) ExitObjectLiteralExpression(ctx *ObjectLiteralExpressionContext)

ExitObjectLiteralExpression is called when production ObjectLiteralExpression is exited.

func (*BaseECMAScriptListener) ExitParenthesizedExpression 

func (s *BaseECMAScriptListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext)

ExitParenthesizedExpression is called when production ParenthesizedExpression is exited.

func (*BaseECMAScriptListener) ExitPostDecreaseExpression 

func (s *BaseECMAScriptListener) ExitPostDecreaseExpression(ctx *PostDecreaseExpressionContext)

ExitPostDecreaseExpression is called when production PostDecreaseExpression is exited.

func (*BaseECMAScriptListener) ExitPostIncrementExpression 

func (s *BaseECMAScriptListener) ExitPostIncrementExpression(ctx *PostIncrementExpressionContext)

ExitPostIncrementExpression is called when production PostIncrementExpression is exited.

func (*BaseECMAScriptListener) ExitPreDecreaseExpression 

func (s *BaseECMAScriptListener) ExitPreDecreaseExpression(ctx *PreDecreaseExpressionContext)

ExitPreDecreaseExpression is called when production PreDecreaseExpression is exited.

func (*BaseECMAScriptListener) ExitPreIncrementExpression 

func (s *BaseECMAScriptListener) ExitPreIncrementExpression(ctx *PreIncrementExpressionContext)

ExitPreIncrementExpression is called when production PreIncrementExpression is exited.

func (*BaseECMAScriptListener) ExitProgram 

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

ExitProgram is called when production program is exited.

func (*BaseECMAScriptListener) ExitPropertyExpressionAssignment 

func (s *BaseECMAScriptListener) ExitPropertyExpressionAssignment(ctx *PropertyExpressionAssignmentContext)

ExitPropertyExpressionAssignment is called when production PropertyExpressionAssignment is exited.

func (*BaseECMAScriptListener) ExitPropertyGetter 

func (s *BaseECMAScriptListener) ExitPropertyGetter(ctx *PropertyGetterContext)

ExitPropertyGetter is called when production PropertyGetter is exited.

func (*BaseECMAScriptListener) ExitPropertyName 

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

ExitPropertyName is called when production propertyName is exited.

func (*BaseECMAScriptListener) ExitPropertyNameAndValueList 

func (s *BaseECMAScriptListener) ExitPropertyNameAndValueList(ctx *PropertyNameAndValueListContext)

ExitPropertyNameAndValueList is called when production propertyNameAndValueList is exited.

func (*BaseECMAScriptListener) ExitPropertySetParameterList 

func (s *BaseECMAScriptListener) ExitPropertySetParameterList(ctx *PropertySetParameterListContext)

ExitPropertySetParameterList is called when production propertySetParameterList is exited.

func (*BaseECMAScriptListener) ExitPropertySetter 

func (s *BaseECMAScriptListener) ExitPropertySetter(ctx *PropertySetterContext)

ExitPropertySetter is called when production PropertySetter is exited.

func (*BaseECMAScriptListener) ExitRelationalExpression 

func (s *BaseECMAScriptListener) ExitRelationalExpression(ctx *RelationalExpressionContext)

ExitRelationalExpression is called when production RelationalExpression is exited.

func (*BaseECMAScriptListener) ExitReservedWord 

func (s *BaseECMAScriptListener) ExitReservedWord(ctx *ReservedWordContext)

ExitReservedWord is called when production reservedWord is exited.

func (*BaseECMAScriptListener) ExitReturnStatement 

func (s *BaseECMAScriptListener) ExitReturnStatement(ctx *ReturnStatementContext)

ExitReturnStatement is called when production returnStatement is exited.

func (*BaseECMAScriptListener) ExitSetter 

func (s *BaseECMAScriptListener) ExitSetter(ctx *SetterContext)

ExitSetter is called when production setter is exited.

func (*BaseECMAScriptListener) ExitSourceElement 

func (s *BaseECMAScriptListener) ExitSourceElement(ctx *SourceElementContext)

ExitSourceElement is called when production sourceElement is exited.

func (*BaseECMAScriptListener) ExitSourceElements 

func (s *BaseECMAScriptListener) ExitSourceElements(ctx *SourceElementsContext)

ExitSourceElements is called when production sourceElements is exited.

func (*BaseECMAScriptListener) ExitStatement 

func (s *BaseECMAScriptListener) ExitStatement(ctx *StatementContext)

ExitStatement is called when production statement is exited.

func (*BaseECMAScriptListener) ExitStatementList 

func (s *BaseECMAScriptListener) ExitStatementList(ctx *StatementListContext)

ExitStatementList is called when production statementList is exited.

func (*BaseECMAScriptListener) ExitSwitchStatement 

func (s *BaseECMAScriptListener) ExitSwitchStatement(ctx *SwitchStatementContext)

ExitSwitchStatement is called when production switchStatement is exited.

func (*BaseECMAScriptListener) ExitTernaryExpression 

func (s *BaseECMAScriptListener) ExitTernaryExpression(ctx *TernaryExpressionContext)

ExitTernaryExpression is called when production TernaryExpression is exited.

func (*BaseECMAScriptListener) ExitThisExpression 

func (s *BaseECMAScriptListener) ExitThisExpression(ctx *ThisExpressionContext)

ExitThisExpression is called when production ThisExpression is exited.

func (*BaseECMAScriptListener) ExitThrowStatement 

func (s *BaseECMAScriptListener) ExitThrowStatement(ctx *ThrowStatementContext)

ExitThrowStatement is called when production throwStatement is exited.

func (*BaseECMAScriptListener) ExitTryStatement 

func (s *BaseECMAScriptListener) ExitTryStatement(ctx *TryStatementContext)

ExitTryStatement is called when production tryStatement is exited.

func (*BaseECMAScriptListener) ExitTypeofExpression 

func (s *BaseECMAScriptListener) ExitTypeofExpression(ctx *TypeofExpressionContext)

ExitTypeofExpression is called when production TypeofExpression is exited.

func (*BaseECMAScriptListener) ExitUnaryMinusExpression 

func (s *BaseECMAScriptListener) ExitUnaryMinusExpression(ctx *UnaryMinusExpressionContext)

ExitUnaryMinusExpression is called when production UnaryMinusExpression is exited.

func (*BaseECMAScriptListener) ExitUnaryPlusExpression 

func (s *BaseECMAScriptListener) ExitUnaryPlusExpression(ctx *UnaryPlusExpressionContext)

ExitUnaryPlusExpression is called when production UnaryPlusExpression is exited.

func (*BaseECMAScriptListener) ExitVariableDeclaration 

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

ExitVariableDeclaration is called when production variableDeclaration is exited.

func (*BaseECMAScriptListener) ExitVariableDeclarationList 

func (s *BaseECMAScriptListener) ExitVariableDeclarationList(ctx *VariableDeclarationListContext)

ExitVariableDeclarationList is called when production variableDeclarationList is exited.

func (*BaseECMAScriptListener) ExitVariableStatement 

func (s *BaseECMAScriptListener) ExitVariableStatement(ctx *VariableStatementContext)

ExitVariableStatement is called when production variableStatement is exited.

func (*BaseECMAScriptListener) ExitVoidExpression 

func (s *BaseECMAScriptListener) ExitVoidExpression(ctx *VoidExpressionContext)

ExitVoidExpression is called when production VoidExpression is exited.

func (*BaseECMAScriptListener) ExitVoidStatement 

func (s *BaseECMAScriptListener) ExitVoidStatement(ctx *VoidStatementContext)

ExitVoidStatement is called when production voidStatement is exited.

func (*BaseECMAScriptListener) ExitWhileStatement 

func (s *BaseECMAScriptListener) ExitWhileStatement(ctx *WhileStatementContext)

ExitWhileStatement is called when production WhileStatement is exited.

func (*BaseECMAScriptListener) ExitWithStatement 

func (s *BaseECMAScriptListener) ExitWithStatement(ctx *WithStatementContext)

ExitWithStatement is called when production withStatement is exited.

func (*BaseECMAScriptListener) VisitErrorNode 

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

VisitErrorNode is called when an error node is visited.

func (*BaseECMAScriptListener) VisitTerminal 

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

VisitTerminal is called when a terminal node is visited.

type BitAndExpressionContext 

type BitAndExpressionContext struct {
	*SingleExpressionContext
}

func NewBitAndExpressionContext 

func NewBitAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndExpressionContext

func (*BitAndExpressionContext) AllSingleExpression 

func (s *BitAndExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitAndExpressionContext) BitAnd 

func (s *BitAndExpressionContext) BitAnd() antlr.TerminalNode

func (*BitAndExpressionContext) EnterRule 

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

func (*BitAndExpressionContext) ExitRule 

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

func (*BitAndExpressionContext) GetRuleContext 

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

func (*BitAndExpressionContext) SingleExpression 

func (s *BitAndExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitNotExpressionContext 

type BitNotExpressionContext struct {
	*SingleExpressionContext
}

func NewBitNotExpressionContext 

func NewBitNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitNotExpressionContext

func (*BitNotExpressionContext) BitNot 

func (s *BitNotExpressionContext) BitNot() antlr.TerminalNode

func (*BitNotExpressionContext) EnterRule 

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

func (*BitNotExpressionContext) ExitRule 

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

func (*BitNotExpressionContext) GetRuleContext 

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

func (*BitNotExpressionContext) SingleExpression 

func (s *BitNotExpressionContext) SingleExpression() ISingleExpressionContext

type BitOrExpressionContext 

type BitOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitOrExpressionContext 

func NewBitOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrExpressionContext

func (*BitOrExpressionContext) AllSingleExpression 

func (s *BitOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitOrExpressionContext) BitOr 

func (s *BitOrExpressionContext) BitOr() antlr.TerminalNode

func (*BitOrExpressionContext) EnterRule 

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

func (*BitOrExpressionContext) ExitRule 

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

func (*BitOrExpressionContext) GetRuleContext 

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

func (*BitOrExpressionContext) SingleExpression 

func (s *BitOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitShiftExpressionContext 

type BitShiftExpressionContext struct {
	*SingleExpressionContext
}

func NewBitShiftExpressionContext 

func NewBitShiftExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitShiftExpressionContext

func (*BitShiftExpressionContext) AllSingleExpression 

func (s *BitShiftExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitShiftExpressionContext) EnterRule 

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

func (*BitShiftExpressionContext) ExitRule 

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

func (*BitShiftExpressionContext) GetRuleContext 

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

func (*BitShiftExpressionContext) LeftShiftArithmetic 

func (s *BitShiftExpressionContext) LeftShiftArithmetic() antlr.TerminalNode

func (*BitShiftExpressionContext) RightShiftArithmetic 

func (s *BitShiftExpressionContext) RightShiftArithmetic() antlr.TerminalNode

func (*BitShiftExpressionContext) RightShiftLogical 

func (s *BitShiftExpressionContext) RightShiftLogical() antlr.TerminalNode

func (*BitShiftExpressionContext) SingleExpression 

func (s *BitShiftExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitXOrExpressionContext 

type BitXOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitXOrExpressionContext 

func NewBitXOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXOrExpressionContext

func (*BitXOrExpressionContext) AllSingleExpression 

func (s *BitXOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitXOrExpressionContext) BitXOr 

func (s *BitXOrExpressionContext) BitXOr() antlr.TerminalNode

func (*BitXOrExpressionContext) EnterRule 

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

func (*BitXOrExpressionContext) ExitRule 

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

func (*BitXOrExpressionContext) GetRuleContext 

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

func (*BitXOrExpressionContext) SingleExpression 

func (s *BitXOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BlockContext 

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

func NewBlockContext 

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

func NewEmptyBlockContext 

func NewEmptyBlockContext() *BlockContext

func (*BlockContext) CloseBrace 

func (s *BlockContext) CloseBrace() antlr.TerminalNode

func (*BlockContext) EnterRule 

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

func (*BlockContext) ExitRule 

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

func (*BlockContext) GetParser 

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

func (*BlockContext) GetRuleContext 

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

func (*BlockContext) IsBlockContext 

func (*BlockContext) IsBlockContext()

func (*BlockContext) OpenBrace 

func (s *BlockContext) OpenBrace() antlr.TerminalNode

func (*BlockContext) StatementList 

func (s *BlockContext) StatementList() IStatementListContext

func (*BlockContext) ToStringTree 

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

type BreakStatementContext 

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

func NewBreakStatementContext 

func NewBreakStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStatementContext

func NewEmptyBreakStatementContext 

func NewEmptyBreakStatementContext() *BreakStatementContext

func (*BreakStatementContext) Break 

func (s *BreakStatementContext) Break() antlr.TerminalNode

func (*BreakStatementContext) EnterRule 

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

func (*BreakStatementContext) Eos 

func (s *BreakStatementContext) Eos() IEosContext

func (*BreakStatementContext) ExitRule 

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

func (*BreakStatementContext) GetParser 

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

func (*BreakStatementContext) GetRuleContext 

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

func (*BreakStatementContext) Identifier 

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

func (*BreakStatementContext) IsBreakStatementContext 

func (*BreakStatementContext) IsBreakStatementContext()

func (*BreakStatementContext) ToStringTree 

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

type CaseBlockContext 

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

func NewCaseBlockContext 

func NewCaseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseBlockContext

func NewEmptyCaseBlockContext 

func NewEmptyCaseBlockContext() *CaseBlockContext

func (*CaseBlockContext) AllCaseClauses 

func (s *CaseBlockContext) AllCaseClauses() []ICaseClausesContext

func (*CaseBlockContext) CaseClauses 

func (s *CaseBlockContext) CaseClauses(i int) ICaseClausesContext

func (*CaseBlockContext) CloseBrace 

func (s *CaseBlockContext) CloseBrace() antlr.TerminalNode

func (*CaseBlockContext) DefaultClause 

func (s *CaseBlockContext) DefaultClause() IDefaultClauseContext

func (*CaseBlockContext) EnterRule 

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

func (*CaseBlockContext) ExitRule 

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

func (*CaseBlockContext) GetParser 

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

func (*CaseBlockContext) GetRuleContext 

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

func (*CaseBlockContext) IsCaseBlockContext 

func (*CaseBlockContext) IsCaseBlockContext()

func (*CaseBlockContext) OpenBrace 

func (s *CaseBlockContext) OpenBrace() antlr.TerminalNode

func (*CaseBlockContext) ToStringTree 

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

type CaseClauseContext 

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

func NewCaseClauseContext 

func NewCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClauseContext

func NewEmptyCaseClauseContext 

func NewEmptyCaseClauseContext() *CaseClauseContext

func (*CaseClauseContext) Case 

func (s *CaseClauseContext) Case() antlr.TerminalNode

func (*CaseClauseContext) Colon 

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

func (*CaseClauseContext) EnterRule 

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

func (*CaseClauseContext) ExitRule 

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

func (*CaseClauseContext) ExpressionSequence 

func (s *CaseClauseContext) ExpressionSequence() IExpressionSequenceContext

func (*CaseClauseContext) GetParser 

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

func (*CaseClauseContext) GetRuleContext 

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

func (*CaseClauseContext) IsCaseClauseContext 

func (*CaseClauseContext) IsCaseClauseContext()

func (*CaseClauseContext) StatementList 

func (s *CaseClauseContext) StatementList() IStatementListContext

func (*CaseClauseContext) ToStringTree 

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

type CaseClausesContext 

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

func NewCaseClausesContext 

func NewCaseClausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClausesContext

func NewEmptyCaseClausesContext 

func NewEmptyCaseClausesContext() *CaseClausesContext

func (*CaseClausesContext) AllCaseClause 

func (s *CaseClausesContext) AllCaseClause() []ICaseClauseContext

func (*CaseClausesContext) CaseClause 

func (s *CaseClausesContext) CaseClause(i int) ICaseClauseContext

func (*CaseClausesContext) EnterRule 

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

func (*CaseClausesContext) ExitRule 

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

func (*CaseClausesContext) GetParser 

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

func (*CaseClausesContext) GetRuleContext 

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

func (*CaseClausesContext) IsCaseClausesContext 

func (*CaseClausesContext) IsCaseClausesContext()

func (*CaseClausesContext) ToStringTree 

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

type CatchProductionContext 

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

func NewCatchProductionContext 

func NewCatchProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchProductionContext

func NewEmptyCatchProductionContext 

func NewEmptyCatchProductionContext() *CatchProductionContext

func (*CatchProductionContext) Block 

func (s *CatchProductionContext) Block() IBlockContext

func (*CatchProductionContext) Catch 

func (s *CatchProductionContext) Catch() antlr.TerminalNode

func (*CatchProductionContext) CloseParen 

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

func (*CatchProductionContext) EnterRule 

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

func (*CatchProductionContext) ExitRule 

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

func (*CatchProductionContext) GetParser 

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

func (*CatchProductionContext) GetRuleContext 

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

func (*CatchProductionContext) Identifier 

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

func (*CatchProductionContext) IsCatchProductionContext 

func (*CatchProductionContext) IsCatchProductionContext()

func (*CatchProductionContext) OpenParen 

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

func (*CatchProductionContext) ToStringTree 

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

type ContinueStatementContext 

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

func NewContinueStatementContext 

func NewContinueStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStatementContext

func NewEmptyContinueStatementContext 

func NewEmptyContinueStatementContext() *ContinueStatementContext

func (*ContinueStatementContext) Continue 

func (s *ContinueStatementContext) Continue() antlr.TerminalNode

func (*ContinueStatementContext) EnterRule 

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

func (*ContinueStatementContext) Eos 

func (s *ContinueStatementContext) Eos() IEosContext

func (*ContinueStatementContext) ExitRule 

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

func (*ContinueStatementContext) GetParser 

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

func (*ContinueStatementContext) GetRuleContext 

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

func (*ContinueStatementContext) Identifier 

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

func (*ContinueStatementContext) IsContinueStatementContext 

func (*ContinueStatementContext) IsContinueStatementContext()

func (*ContinueStatementContext) ToStringTree 

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

type DebuggerStatementContext 

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

func NewDebuggerStatementContext 

func NewDebuggerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DebuggerStatementContext

func NewEmptyDebuggerStatementContext 

func NewEmptyDebuggerStatementContext() *DebuggerStatementContext

func (*DebuggerStatementContext) Debugger 

func (s *DebuggerStatementContext) Debugger() antlr.TerminalNode

func (*DebuggerStatementContext) EnterRule 

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

func (*DebuggerStatementContext) Eos 

func (s *DebuggerStatementContext) Eos() IEosContext

func (*DebuggerStatementContext) ExitRule 

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

func (*DebuggerStatementContext) GetParser 

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

func (*DebuggerStatementContext) GetRuleContext 

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

func (*DebuggerStatementContext) IsDebuggerStatementContext 

func (*DebuggerStatementContext) IsDebuggerStatementContext()

func (*DebuggerStatementContext) ToStringTree 

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

type DefaultClauseContext 

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

func NewDefaultClauseContext 

func NewDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultClauseContext

func NewEmptyDefaultClauseContext 

func NewEmptyDefaultClauseContext() *DefaultClauseContext

func (*DefaultClauseContext) Colon 

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

func (*DefaultClauseContext) Default 

func (s *DefaultClauseContext) Default() antlr.TerminalNode

func (*DefaultClauseContext) EnterRule 

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

func (*DefaultClauseContext) ExitRule 

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

func (*DefaultClauseContext) GetParser 

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

func (*DefaultClauseContext) GetRuleContext 

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

func (*DefaultClauseContext) IsDefaultClauseContext 

func (*DefaultClauseContext) IsDefaultClauseContext()

func (*DefaultClauseContext) StatementList 

func (s *DefaultClauseContext) StatementList() IStatementListContext

func (*DefaultClauseContext) ToStringTree 

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

type DeleteExpressionContext 

type DeleteExpressionContext struct {
	*SingleExpressionContext
}

func NewDeleteExpressionContext 

func NewDeleteExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeleteExpressionContext

func (*DeleteExpressionContext) Delete 

func (s *DeleteExpressionContext) Delete() antlr.TerminalNode

func (*DeleteExpressionContext) EnterRule 

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

func (*DeleteExpressionContext) ExitRule 

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

func (*DeleteExpressionContext) GetRuleContext 

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

func (*DeleteExpressionContext) SingleExpression 

func (s *DeleteExpressionContext) SingleExpression() ISingleExpressionContext

type DoStatementContext 

type DoStatementContext struct {
	*IterationStatementContext
}

func NewDoStatementContext 

func NewDoStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoStatementContext

func (*DoStatementContext) CloseParen 

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

func (*DoStatementContext) Do 

func (s *DoStatementContext) Do() antlr.TerminalNode

func (*DoStatementContext) EnterRule 

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

func (*DoStatementContext) Eos 

func (s *DoStatementContext) Eos() IEosContext

func (*DoStatementContext) ExitRule 

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

func (*DoStatementContext) ExpressionSequence 

func (s *DoStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*DoStatementContext) GetRuleContext 

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

func (*DoStatementContext) OpenParen 

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

func (*DoStatementContext) Statement 

func (s *DoStatementContext) Statement() IStatementContext

func (*DoStatementContext) While 

func (s *DoStatementContext) While() antlr.TerminalNode

type ECMAScriptLexer 

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

func NewECMAScriptLexer 

func NewECMAScriptLexer(input antlr.CharStream) *ECMAScriptLexer

func (*ECMAScriptLexer) Implements_Sempred 

func (p *ECMAScriptLexer) Implements_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Interface_Sempred 

func (p *ECMAScriptLexer) Interface_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Let_Sempred 

func (p *ECMAScriptLexer) Let_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) OctalIntegerLiteral_Sempred 

func (p *ECMAScriptLexer) OctalIntegerLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Package_Sempred 

func (p *ECMAScriptLexer) Package_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Private_Sempred 

func (p *ECMAScriptLexer) Private_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Protected_Sempred 

func (p *ECMAScriptLexer) Protected_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Public_Sempred 

func (p *ECMAScriptLexer) Public_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) RegularExpressionLiteral_Sempred 

func (p *ECMAScriptLexer) RegularExpressionLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Sempred 

func (l *ECMAScriptLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*ECMAScriptLexer) Static_Sempred 

func (p *ECMAScriptLexer) Static_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptLexer) Yield_Sempred 

func (p *ECMAScriptLexer) Yield_Sempred(localctx antlr.RuleContext, predIndex int) bool

type ECMAScriptListener 

type ECMAScriptListener interface {
	antlr.ParseTreeListener

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

	// EnterSourceElements is called when entering the sourceElements production.
	EnterSourceElements(c *SourceElementsContext)

	// EnterSourceElement is called when entering the sourceElement production.
	EnterSourceElement(c *SourceElementContext)

	// EnterStatement is called when entering the statement production.
	EnterStatement(c *StatementContext)

	// EnterBlock is called when entering the block production.
	EnterBlock(c *BlockContext)

	// EnterStatementList is called when entering the statementList production.
	EnterStatementList(c *StatementListContext)

	// EnterVariableStatement is called when entering the variableStatement production.
	EnterVariableStatement(c *VariableStatementContext)

	// EnterVariableDeclarationList is called when entering the variableDeclarationList production.
	EnterVariableDeclarationList(c *VariableDeclarationListContext)

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

	// EnterInitialiser is called when entering the initialiser production.
	EnterInitialiser(c *InitialiserContext)

	// EnterVoidStatement is called when entering the voidStatement production.
	EnterVoidStatement(c *VoidStatementContext)

	// EnterExpressionStatement is called when entering the expressionStatement production.
	EnterExpressionStatement(c *ExpressionStatementContext)

	// EnterIfStatement is called when entering the ifStatement production.
	EnterIfStatement(c *IfStatementContext)

	// EnterDoStatement is called when entering the DoStatement production.
	EnterDoStatement(c *DoStatementContext)

	// EnterWhileStatement is called when entering the WhileStatement production.
	EnterWhileStatement(c *WhileStatementContext)

	// EnterForStatement is called when entering the ForStatement production.
	EnterForStatement(c *ForStatementContext)

	// EnterForVarStatement is called when entering the ForVarStatement production.
	EnterForVarStatement(c *ForVarStatementContext)

	// EnterForInStatement is called when entering the ForInStatement production.
	EnterForInStatement(c *ForInStatementContext)

	// EnterForVarInStatement is called when entering the ForVarInStatement production.
	EnterForVarInStatement(c *ForVarInStatementContext)

	// EnterContinueStatement is called when entering the continueStatement production.
	EnterContinueStatement(c *ContinueStatementContext)

	// EnterBreakStatement is called when entering the breakStatement production.
	EnterBreakStatement(c *BreakStatementContext)

	// EnterReturnStatement is called when entering the returnStatement production.
	EnterReturnStatement(c *ReturnStatementContext)

	// EnterWithStatement is called when entering the withStatement production.
	EnterWithStatement(c *WithStatementContext)

	// EnterSwitchStatement is called when entering the switchStatement production.
	EnterSwitchStatement(c *SwitchStatementContext)

	// EnterCaseBlock is called when entering the caseBlock production.
	EnterCaseBlock(c *CaseBlockContext)

	// EnterCaseClauses is called when entering the caseClauses production.
	EnterCaseClauses(c *CaseClausesContext)

	// EnterCaseClause is called when entering the caseClause production.
	EnterCaseClause(c *CaseClauseContext)

	// EnterDefaultClause is called when entering the defaultClause production.
	EnterDefaultClause(c *DefaultClauseContext)

	// EnterLabelledStatement is called when entering the labelledStatement production.
	EnterLabelledStatement(c *LabelledStatementContext)

	// EnterThrowStatement is called when entering the throwStatement production.
	EnterThrowStatement(c *ThrowStatementContext)

	// EnterTryStatement is called when entering the tryStatement production.
	EnterTryStatement(c *TryStatementContext)

	// EnterCatchProduction is called when entering the catchProduction production.
	EnterCatchProduction(c *CatchProductionContext)

	// EnterFinallyProduction is called when entering the finallyProduction production.
	EnterFinallyProduction(c *FinallyProductionContext)

	// EnterDebuggerStatement is called when entering the debuggerStatement production.
	EnterDebuggerStatement(c *DebuggerStatementContext)

	// EnterFunctionDeclaration is called when entering the functionDeclaration production.
	EnterFunctionDeclaration(c *FunctionDeclarationContext)

	// EnterFormalParameterList is called when entering the formalParameterList production.
	EnterFormalParameterList(c *FormalParameterListContext)

	// EnterFunctionBody is called when entering the functionBody production.
	EnterFunctionBody(c *FunctionBodyContext)

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

	// EnterElementList is called when entering the elementList production.
	EnterElementList(c *ElementListContext)

	// EnterElision is called when entering the elision production.
	EnterElision(c *ElisionContext)

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

	// EnterPropertyNameAndValueList is called when entering the propertyNameAndValueList production.
	EnterPropertyNameAndValueList(c *PropertyNameAndValueListContext)

	// EnterPropertyExpressionAssignment is called when entering the PropertyExpressionAssignment production.
	EnterPropertyExpressionAssignment(c *PropertyExpressionAssignmentContext)

	// EnterPropertyGetter is called when entering the PropertyGetter production.
	EnterPropertyGetter(c *PropertyGetterContext)

	// EnterPropertySetter is called when entering the PropertySetter production.
	EnterPropertySetter(c *PropertySetterContext)

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

	// EnterPropertySetParameterList is called when entering the propertySetParameterList production.
	EnterPropertySetParameterList(c *PropertySetParameterListContext)

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

	// EnterArgumentList is called when entering the argumentList production.
	EnterArgumentList(c *ArgumentListContext)

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

	// EnterTernaryExpression is called when entering the TernaryExpression production.
	EnterTernaryExpression(c *TernaryExpressionContext)

	// EnterLogicalAndExpression is called when entering the LogicalAndExpression production.
	EnterLogicalAndExpression(c *LogicalAndExpressionContext)

	// EnterPreIncrementExpression is called when entering the PreIncrementExpression production.
	EnterPreIncrementExpression(c *PreIncrementExpressionContext)

	// EnterObjectLiteralExpression is called when entering the ObjectLiteralExpression production.
	EnterObjectLiteralExpression(c *ObjectLiteralExpressionContext)

	// EnterInExpression is called when entering the InExpression production.
	EnterInExpression(c *InExpressionContext)

	// EnterLogicalOrExpression is called when entering the LogicalOrExpression production.
	EnterLogicalOrExpression(c *LogicalOrExpressionContext)

	// EnterNotExpression is called when entering the NotExpression production.
	EnterNotExpression(c *NotExpressionContext)

	// EnterPreDecreaseExpression is called when entering the PreDecreaseExpression production.
	EnterPreDecreaseExpression(c *PreDecreaseExpressionContext)

	// EnterArgumentsExpression is called when entering the ArgumentsExpression production.
	EnterArgumentsExpression(c *ArgumentsExpressionContext)

	// EnterThisExpression is called when entering the ThisExpression production.
	EnterThisExpression(c *ThisExpressionContext)

	// EnterFunctionExpression is called when entering the FunctionExpression production.
	EnterFunctionExpression(c *FunctionExpressionContext)

	// EnterUnaryMinusExpression is called when entering the UnaryMinusExpression production.
	EnterUnaryMinusExpression(c *UnaryMinusExpressionContext)

	// EnterAssignmentExpression is called when entering the AssignmentExpression production.
	EnterAssignmentExpression(c *AssignmentExpressionContext)

	// EnterPostDecreaseExpression is called when entering the PostDecreaseExpression production.
	EnterPostDecreaseExpression(c *PostDecreaseExpressionContext)

	// EnterTypeofExpression is called when entering the TypeofExpression production.
	EnterTypeofExpression(c *TypeofExpressionContext)

	// EnterInstanceofExpression is called when entering the InstanceofExpression production.
	EnterInstanceofExpression(c *InstanceofExpressionContext)

	// EnterUnaryPlusExpression is called when entering the UnaryPlusExpression production.
	EnterUnaryPlusExpression(c *UnaryPlusExpressionContext)

	// EnterDeleteExpression is called when entering the DeleteExpression production.
	EnterDeleteExpression(c *DeleteExpressionContext)

	// EnterEqualityExpression is called when entering the EqualityExpression production.
	EnterEqualityExpression(c *EqualityExpressionContext)

	// EnterBitXOrExpression is called when entering the BitXOrExpression production.
	EnterBitXOrExpression(c *BitXOrExpressionContext)

	// EnterMultiplicativeExpression is called when entering the MultiplicativeExpression production.
	EnterMultiplicativeExpression(c *MultiplicativeExpressionContext)

	// EnterBitShiftExpression is called when entering the BitShiftExpression production.
	EnterBitShiftExpression(c *BitShiftExpressionContext)

	// EnterParenthesizedExpression is called when entering the ParenthesizedExpression production.
	EnterParenthesizedExpression(c *ParenthesizedExpressionContext)

	// EnterAdditiveExpression is called when entering the AdditiveExpression production.
	EnterAdditiveExpression(c *AdditiveExpressionContext)

	// EnterRelationalExpression is called when entering the RelationalExpression production.
	EnterRelationalExpression(c *RelationalExpressionContext)

	// EnterPostIncrementExpression is called when entering the PostIncrementExpression production.
	EnterPostIncrementExpression(c *PostIncrementExpressionContext)

	// EnterBitNotExpression is called when entering the BitNotExpression production.
	EnterBitNotExpression(c *BitNotExpressionContext)

	// EnterNewExpression is called when entering the NewExpression production.
	EnterNewExpression(c *NewExpressionContext)

	// EnterLiteralExpression is called when entering the LiteralExpression production.
	EnterLiteralExpression(c *LiteralExpressionContext)

	// EnterArrayLiteralExpression is called when entering the ArrayLiteralExpression production.
	EnterArrayLiteralExpression(c *ArrayLiteralExpressionContext)

	// EnterMemberDotExpression is called when entering the MemberDotExpression production.
	EnterMemberDotExpression(c *MemberDotExpressionContext)

	// EnterMemberIndexExpression is called when entering the MemberIndexExpression production.
	EnterMemberIndexExpression(c *MemberIndexExpressionContext)

	// EnterIdentifierExpression is called when entering the IdentifierExpression production.
	EnterIdentifierExpression(c *IdentifierExpressionContext)

	// EnterBitAndExpression is called when entering the BitAndExpression production.
	EnterBitAndExpression(c *BitAndExpressionContext)

	// EnterBitOrExpression is called when entering the BitOrExpression production.
	EnterBitOrExpression(c *BitOrExpressionContext)

	// EnterAssignmentOperatorExpression is called when entering the AssignmentOperatorExpression production.
	EnterAssignmentOperatorExpression(c *AssignmentOperatorExpressionContext)

	// EnterVoidExpression is called when entering the VoidExpression production.
	EnterVoidExpression(c *VoidExpressionContext)

	// EnterAssignmentOperator is called when entering the assignmentOperator production.
	EnterAssignmentOperator(c *AssignmentOperatorContext)

	// EnterLiteral is called when entering the literal production.
	EnterLiteral(c *LiteralContext)

	// EnterNumericLiteral is called when entering the numericLiteral production.
	EnterNumericLiteral(c *NumericLiteralContext)

	// EnterIdentifierName is called when entering the identifierName production.
	EnterIdentifierName(c *IdentifierNameContext)

	// EnterReservedWord is called when entering the reservedWord production.
	EnterReservedWord(c *ReservedWordContext)

	// EnterKeyword is called when entering the keyword production.
	EnterKeyword(c *KeywordContext)

	// EnterFutureReservedWord is called when entering the futureReservedWord production.
	EnterFutureReservedWord(c *FutureReservedWordContext)

	// EnterGetter is called when entering the getter production.
	EnterGetter(c *GetterContext)

	// EnterSetter is called when entering the setter production.
	EnterSetter(c *SetterContext)

	// EnterEos is called when entering the eos production.
	EnterEos(c *EosContext)

	// EnterEof is called when entering the eof production.
	EnterEof(c *EofContext)

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

	// ExitSourceElements is called when exiting the sourceElements production.
	ExitSourceElements(c *SourceElementsContext)

	// ExitSourceElement is called when exiting the sourceElement production.
	ExitSourceElement(c *SourceElementContext)

	// ExitStatement is called when exiting the statement production.
	ExitStatement(c *StatementContext)

	// ExitBlock is called when exiting the block production.
	ExitBlock(c *BlockContext)

	// ExitStatementList is called when exiting the statementList production.
	ExitStatementList(c *StatementListContext)

	// ExitVariableStatement is called when exiting the variableStatement production.
	ExitVariableStatement(c *VariableStatementContext)

	// ExitVariableDeclarationList is called when exiting the variableDeclarationList production.
	ExitVariableDeclarationList(c *VariableDeclarationListContext)

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

	// ExitInitialiser is called when exiting the initialiser production.
	ExitInitialiser(c *InitialiserContext)

	// ExitVoidStatement is called when exiting the voidStatement production.
	ExitVoidStatement(c *VoidStatementContext)

	// ExitExpressionStatement is called when exiting the expressionStatement production.
	ExitExpressionStatement(c *ExpressionStatementContext)

	// ExitIfStatement is called when exiting the ifStatement production.
	ExitIfStatement(c *IfStatementContext)

	// ExitDoStatement is called when exiting the DoStatement production.
	ExitDoStatement(c *DoStatementContext)

	// ExitWhileStatement is called when exiting the WhileStatement production.
	ExitWhileStatement(c *WhileStatementContext)

	// ExitForStatement is called when exiting the ForStatement production.
	ExitForStatement(c *ForStatementContext)

	// ExitForVarStatement is called when exiting the ForVarStatement production.
	ExitForVarStatement(c *ForVarStatementContext)

	// ExitForInStatement is called when exiting the ForInStatement production.
	ExitForInStatement(c *ForInStatementContext)

	// ExitForVarInStatement is called when exiting the ForVarInStatement production.
	ExitForVarInStatement(c *ForVarInStatementContext)

	// ExitContinueStatement is called when exiting the continueStatement production.
	ExitContinueStatement(c *ContinueStatementContext)

	// ExitBreakStatement is called when exiting the breakStatement production.
	ExitBreakStatement(c *BreakStatementContext)

	// ExitReturnStatement is called when exiting the returnStatement production.
	ExitReturnStatement(c *ReturnStatementContext)

	// ExitWithStatement is called when exiting the withStatement production.
	ExitWithStatement(c *WithStatementContext)

	// ExitSwitchStatement is called when exiting the switchStatement production.
	ExitSwitchStatement(c *SwitchStatementContext)

	// ExitCaseBlock is called when exiting the caseBlock production.
	ExitCaseBlock(c *CaseBlockContext)

	// ExitCaseClauses is called when exiting the caseClauses production.
	ExitCaseClauses(c *CaseClausesContext)

	// ExitCaseClause is called when exiting the caseClause production.
	ExitCaseClause(c *CaseClauseContext)

	// ExitDefaultClause is called when exiting the defaultClause production.
	ExitDefaultClause(c *DefaultClauseContext)

	// ExitLabelledStatement is called when exiting the labelledStatement production.
	ExitLabelledStatement(c *LabelledStatementContext)

	// ExitThrowStatement is called when exiting the throwStatement production.
	ExitThrowStatement(c *ThrowStatementContext)

	// ExitTryStatement is called when exiting the tryStatement production.
	ExitTryStatement(c *TryStatementContext)

	// ExitCatchProduction is called when exiting the catchProduction production.
	ExitCatchProduction(c *CatchProductionContext)

	// ExitFinallyProduction is called when exiting the finallyProduction production.
	ExitFinallyProduction(c *FinallyProductionContext)

	// ExitDebuggerStatement is called when exiting the debuggerStatement production.
	ExitDebuggerStatement(c *DebuggerStatementContext)

	// ExitFunctionDeclaration is called when exiting the functionDeclaration production.
	ExitFunctionDeclaration(c *FunctionDeclarationContext)

	// ExitFormalParameterList is called when exiting the formalParameterList production.
	ExitFormalParameterList(c *FormalParameterListContext)

	// ExitFunctionBody is called when exiting the functionBody production.
	ExitFunctionBody(c *FunctionBodyContext)

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

	// ExitElementList is called when exiting the elementList production.
	ExitElementList(c *ElementListContext)

	// ExitElision is called when exiting the elision production.
	ExitElision(c *ElisionContext)

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

	// ExitPropertyNameAndValueList is called when exiting the propertyNameAndValueList production.
	ExitPropertyNameAndValueList(c *PropertyNameAndValueListContext)

	// ExitPropertyExpressionAssignment is called when exiting the PropertyExpressionAssignment production.
	ExitPropertyExpressionAssignment(c *PropertyExpressionAssignmentContext)

	// ExitPropertyGetter is called when exiting the PropertyGetter production.
	ExitPropertyGetter(c *PropertyGetterContext)

	// ExitPropertySetter is called when exiting the PropertySetter production.
	ExitPropertySetter(c *PropertySetterContext)

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

	// ExitPropertySetParameterList is called when exiting the propertySetParameterList production.
	ExitPropertySetParameterList(c *PropertySetParameterListContext)

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

	// ExitArgumentList is called when exiting the argumentList production.
	ExitArgumentList(c *ArgumentListContext)

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

	// ExitTernaryExpression is called when exiting the TernaryExpression production.
	ExitTernaryExpression(c *TernaryExpressionContext)

	// ExitLogicalAndExpression is called when exiting the LogicalAndExpression production.
	ExitLogicalAndExpression(c *LogicalAndExpressionContext)

	// ExitPreIncrementExpression is called when exiting the PreIncrementExpression production.
	ExitPreIncrementExpression(c *PreIncrementExpressionContext)

	// ExitObjectLiteralExpression is called when exiting the ObjectLiteralExpression production.
	ExitObjectLiteralExpression(c *ObjectLiteralExpressionContext)

	// ExitInExpression is called when exiting the InExpression production.
	ExitInExpression(c *InExpressionContext)

	// ExitLogicalOrExpression is called when exiting the LogicalOrExpression production.
	ExitLogicalOrExpression(c *LogicalOrExpressionContext)

	// ExitNotExpression is called when exiting the NotExpression production.
	ExitNotExpression(c *NotExpressionContext)

	// ExitPreDecreaseExpression is called when exiting the PreDecreaseExpression production.
	ExitPreDecreaseExpression(c *PreDecreaseExpressionContext)

	// ExitArgumentsExpression is called when exiting the ArgumentsExpression production.
	ExitArgumentsExpression(c *ArgumentsExpressionContext)

	// ExitThisExpression is called when exiting the ThisExpression production.
	ExitThisExpression(c *ThisExpressionContext)

	// ExitFunctionExpression is called when exiting the FunctionExpression production.
	ExitFunctionExpression(c *FunctionExpressionContext)

	// ExitUnaryMinusExpression is called when exiting the UnaryMinusExpression production.
	ExitUnaryMinusExpression(c *UnaryMinusExpressionContext)

	// ExitAssignmentExpression is called when exiting the AssignmentExpression production.
	ExitAssignmentExpression(c *AssignmentExpressionContext)

	// ExitPostDecreaseExpression is called when exiting the PostDecreaseExpression production.
	ExitPostDecreaseExpression(c *PostDecreaseExpressionContext)

	// ExitTypeofExpression is called when exiting the TypeofExpression production.
	ExitTypeofExpression(c *TypeofExpressionContext)

	// ExitInstanceofExpression is called when exiting the InstanceofExpression production.
	ExitInstanceofExpression(c *InstanceofExpressionContext)

	// ExitUnaryPlusExpression is called when exiting the UnaryPlusExpression production.
	ExitUnaryPlusExpression(c *UnaryPlusExpressionContext)

	// ExitDeleteExpression is called when exiting the DeleteExpression production.
	ExitDeleteExpression(c *DeleteExpressionContext)

	// ExitEqualityExpression is called when exiting the EqualityExpression production.
	ExitEqualityExpression(c *EqualityExpressionContext)

	// ExitBitXOrExpression is called when exiting the BitXOrExpression production.
	ExitBitXOrExpression(c *BitXOrExpressionContext)

	// ExitMultiplicativeExpression is called when exiting the MultiplicativeExpression production.
	ExitMultiplicativeExpression(c *MultiplicativeExpressionContext)

	// ExitBitShiftExpression is called when exiting the BitShiftExpression production.
	ExitBitShiftExpression(c *BitShiftExpressionContext)

	// ExitParenthesizedExpression is called when exiting the ParenthesizedExpression production.
	ExitParenthesizedExpression(c *ParenthesizedExpressionContext)

	// ExitAdditiveExpression is called when exiting the AdditiveExpression production.
	ExitAdditiveExpression(c *AdditiveExpressionContext)

	// ExitRelationalExpression is called when exiting the RelationalExpression production.
	ExitRelationalExpression(c *RelationalExpressionContext)

	// ExitPostIncrementExpression is called when exiting the PostIncrementExpression production.
	ExitPostIncrementExpression(c *PostIncrementExpressionContext)

	// ExitBitNotExpression is called when exiting the BitNotExpression production.
	ExitBitNotExpression(c *BitNotExpressionContext)

	// ExitNewExpression is called when exiting the NewExpression production.
	ExitNewExpression(c *NewExpressionContext)

	// ExitLiteralExpression is called when exiting the LiteralExpression production.
	ExitLiteralExpression(c *LiteralExpressionContext)

	// ExitArrayLiteralExpression is called when exiting the ArrayLiteralExpression production.
	ExitArrayLiteralExpression(c *ArrayLiteralExpressionContext)

	// ExitMemberDotExpression is called when exiting the MemberDotExpression production.
	ExitMemberDotExpression(c *MemberDotExpressionContext)

	// ExitMemberIndexExpression is called when exiting the MemberIndexExpression production.
	ExitMemberIndexExpression(c *MemberIndexExpressionContext)

	// ExitIdentifierExpression is called when exiting the IdentifierExpression production.
	ExitIdentifierExpression(c *IdentifierExpressionContext)

	// ExitBitAndExpression is called when exiting the BitAndExpression production.
	ExitBitAndExpression(c *BitAndExpressionContext)

	// ExitBitOrExpression is called when exiting the BitOrExpression production.
	ExitBitOrExpression(c *BitOrExpressionContext)

	// ExitAssignmentOperatorExpression is called when exiting the AssignmentOperatorExpression production.
	ExitAssignmentOperatorExpression(c *AssignmentOperatorExpressionContext)

	// ExitVoidExpression is called when exiting the VoidExpression production.
	ExitVoidExpression(c *VoidExpressionContext)

	// ExitAssignmentOperator is called when exiting the assignmentOperator production.
	ExitAssignmentOperator(c *AssignmentOperatorContext)

	// ExitLiteral is called when exiting the literal production.
	ExitLiteral(c *LiteralContext)

	// ExitNumericLiteral is called when exiting the numericLiteral production.
	ExitNumericLiteral(c *NumericLiteralContext)

	// ExitIdentifierName is called when exiting the identifierName production.
	ExitIdentifierName(c *IdentifierNameContext)

	// ExitReservedWord is called when exiting the reservedWord production.
	ExitReservedWord(c *ReservedWordContext)

	// ExitKeyword is called when exiting the keyword production.
	ExitKeyword(c *KeywordContext)

	// ExitFutureReservedWord is called when exiting the futureReservedWord production.
	ExitFutureReservedWord(c *FutureReservedWordContext)

	// ExitGetter is called when exiting the getter production.
	ExitGetter(c *GetterContext)

	// ExitSetter is called when exiting the setter production.
	ExitSetter(c *SetterContext)

	// ExitEos is called when exiting the eos production.
	ExitEos(c *EosContext)

	// ExitEof is called when exiting the eof production.
	ExitEof(c *EofContext)
}

ECMAScriptListener is a complete listener for a parse tree produced by ECMAScriptParser.

type ECMAScriptParser 

type ECMAScriptParser struct {
	*antlr.BaseParser
}

func NewECMAScriptParser 

func NewECMAScriptParser(input antlr.TokenStream) *ECMAScriptParser

func (*ECMAScriptParser) ArgumentList 

func (p *ECMAScriptParser) ArgumentList() (localctx IArgumentListContext)

func (*ECMAScriptParser) Arguments 

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

func (*ECMAScriptParser) ArrayLiteral 

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

func (*ECMAScriptParser) AssignmentOperator 

func (p *ECMAScriptParser) AssignmentOperator() (localctx IAssignmentOperatorContext)

func (*ECMAScriptParser) Block 

func (p *ECMAScriptParser) Block() (localctx IBlockContext)

func (*ECMAScriptParser) BreakStatement 

func (p *ECMAScriptParser) BreakStatement() (localctx IBreakStatementContext)

func (*ECMAScriptParser) CaseBlock 

func (p *ECMAScriptParser) CaseBlock() (localctx ICaseBlockContext)

func (*ECMAScriptParser) CaseClause 

func (p *ECMAScriptParser) CaseClause() (localctx ICaseClauseContext)

func (*ECMAScriptParser) CaseClauses 

func (p *ECMAScriptParser) CaseClauses() (localctx ICaseClausesContext)

func (*ECMAScriptParser) CatchProduction 

func (p *ECMAScriptParser) CatchProduction() (localctx ICatchProductionContext)

func (*ECMAScriptParser) ContinueStatement 

func (p *ECMAScriptParser) ContinueStatement() (localctx IContinueStatementContext)

func (*ECMAScriptParser) DebuggerStatement 

func (p *ECMAScriptParser) DebuggerStatement() (localctx IDebuggerStatementContext)

func (*ECMAScriptParser) DefaultClause 

func (p *ECMAScriptParser) DefaultClause() (localctx IDefaultClauseContext)

func (*ECMAScriptParser) ElementList 

func (p *ECMAScriptParser) ElementList() (localctx IElementListContext)

func (*ECMAScriptParser) Elision 

func (p *ECMAScriptParser) Elision() (localctx IElisionContext)

func (*ECMAScriptParser) Eof 

func (p *ECMAScriptParser) Eof() (localctx IEofContext)

func (*ECMAScriptParser) Eos 

func (p *ECMAScriptParser) Eos() (localctx IEosContext)

func (*ECMAScriptParser) Eos_Sempred 

func (p *ECMAScriptParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptParser) ExpressionSequence 

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

func (*ECMAScriptParser) ExpressionStatement 

func (p *ECMAScriptParser) ExpressionStatement() (localctx IExpressionStatementContext)

func (*ECMAScriptParser) ExpressionStatement_Sempred 

func (p *ECMAScriptParser) ExpressionStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptParser) FinallyProduction 

func (p *ECMAScriptParser) FinallyProduction() (localctx IFinallyProductionContext)

func (*ECMAScriptParser) FormalParameterList 

func (p *ECMAScriptParser) FormalParameterList() (localctx IFormalParameterListContext)

func (*ECMAScriptParser) FunctionBody 

func (p *ECMAScriptParser) FunctionBody() (localctx IFunctionBodyContext)

func (*ECMAScriptParser) FunctionDeclaration 

func (p *ECMAScriptParser) FunctionDeclaration() (localctx IFunctionDeclarationContext)

func (*ECMAScriptParser) FutureReservedWord 

func (p *ECMAScriptParser) FutureReservedWord() (localctx IFutureReservedWordContext)

func (*ECMAScriptParser) Getter 

func (p *ECMAScriptParser) Getter() (localctx IGetterContext)

func (*ECMAScriptParser) Getter_Sempred 

func (p *ECMAScriptParser) Getter_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptParser) IdentifierName 

func (p *ECMAScriptParser) IdentifierName() (localctx IIdentifierNameContext)

func (*ECMAScriptParser) IfStatement 

func (p *ECMAScriptParser) IfStatement() (localctx IIfStatementContext)

func (*ECMAScriptParser) Initialiser 

func (p *ECMAScriptParser) Initialiser() (localctx IInitialiserContext)

func (*ECMAScriptParser) IterationStatement 

func (p *ECMAScriptParser) IterationStatement() (localctx IIterationStatementContext)

func (*ECMAScriptParser) Keyword 

func (p *ECMAScriptParser) Keyword() (localctx IKeywordContext)

func (*ECMAScriptParser) LabelledStatement 

func (p *ECMAScriptParser) LabelledStatement() (localctx ILabelledStatementContext)

func (*ECMAScriptParser) Literal 

func (p *ECMAScriptParser) Literal() (localctx ILiteralContext)

func (*ECMAScriptParser) NumericLiteral 

func (p *ECMAScriptParser) NumericLiteral() (localctx INumericLiteralContext)

func (*ECMAScriptParser) ObjectLiteral 

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

func (*ECMAScriptParser) Program 

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

func (*ECMAScriptParser) PropertyAssignment 

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

func (*ECMAScriptParser) PropertyName 

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

func (*ECMAScriptParser) PropertyNameAndValueList 

func (p *ECMAScriptParser) PropertyNameAndValueList() (localctx IPropertyNameAndValueListContext)

func (*ECMAScriptParser) PropertySetParameterList 

func (p *ECMAScriptParser) PropertySetParameterList() (localctx IPropertySetParameterListContext)

func (*ECMAScriptParser) ReservedWord 

func (p *ECMAScriptParser) ReservedWord() (localctx IReservedWordContext)

func (*ECMAScriptParser) ReturnStatement 

func (p *ECMAScriptParser) ReturnStatement() (localctx IReturnStatementContext)

func (*ECMAScriptParser) Sempred 

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

func (*ECMAScriptParser) Setter 

func (p *ECMAScriptParser) Setter() (localctx ISetterContext)

func (*ECMAScriptParser) Setter_Sempred 

func (p *ECMAScriptParser) Setter_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptParser) SingleExpression 

func (p *ECMAScriptParser) SingleExpression() (localctx ISingleExpressionContext)

func (*ECMAScriptParser) SingleExpression_Sempred 

func (p *ECMAScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ECMAScriptParser) SourceElement 

func (p *ECMAScriptParser) SourceElement() (localctx ISourceElementContext)

func (*ECMAScriptParser) SourceElements 

func (p *ECMAScriptParser) SourceElements() (localctx ISourceElementsContext)

func (*ECMAScriptParser) Statement 

func (p *ECMAScriptParser) Statement() (localctx IStatementContext)

func (*ECMAScriptParser) StatementList 

func (p *ECMAScriptParser) StatementList() (localctx IStatementListContext)

func (*ECMAScriptParser) SwitchStatement 

func (p *ECMAScriptParser) SwitchStatement() (localctx ISwitchStatementContext)

func (*ECMAScriptParser) ThrowStatement 

func (p *ECMAScriptParser) ThrowStatement() (localctx IThrowStatementContext)

func (*ECMAScriptParser) TryStatement 

func (p *ECMAScriptParser) TryStatement() (localctx ITryStatementContext)

func (*ECMAScriptParser) VariableDeclaration 

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

func (*ECMAScriptParser) VariableDeclarationList 

func (p *ECMAScriptParser) VariableDeclarationList() (localctx IVariableDeclarationListContext)

func (*ECMAScriptParser) VariableStatement 

func (p *ECMAScriptParser) VariableStatement() (localctx IVariableStatementContext)

func (*ECMAScriptParser) VoidStatement 

func (p *ECMAScriptParser) VoidStatement() (localctx IVoidStatementContext)

func (*ECMAScriptParser) WithStatement 

func (p *ECMAScriptParser) WithStatement() (localctx IWithStatementContext)

type ElementListContext 

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

func NewElementListContext 

func NewElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementListContext

func NewEmptyElementListContext 

func NewEmptyElementListContext() *ElementListContext

func (*ElementListContext) AllComma 

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

func (*ElementListContext) AllElision 

func (s *ElementListContext) AllElision() []IElisionContext

func (*ElementListContext) AllSingleExpression 

func (s *ElementListContext) AllSingleExpression() []ISingleExpressionContext

func (*ElementListContext) Comma 

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

func (*ElementListContext) Elision 

func (s *ElementListContext) Elision(i int) IElisionContext

func (*ElementListContext) EnterRule 

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

func (*ElementListContext) ExitRule 

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

func (*ElementListContext) GetParser 

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

func (*ElementListContext) GetRuleContext 

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

func (*ElementListContext) IsElementListContext 

func (*ElementListContext) IsElementListContext()

func (*ElementListContext) SingleExpression 

func (s *ElementListContext) SingleExpression(i int) ISingleExpressionContext

func (*ElementListContext) ToStringTree 

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

type ElisionContext 

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

func NewElisionContext 

func NewElisionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElisionContext

func NewEmptyElisionContext 

func NewEmptyElisionContext() *ElisionContext

func (*ElisionContext) AllComma 

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

func (*ElisionContext) Comma 

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

func (*ElisionContext) EnterRule 

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

func (*ElisionContext) ExitRule 

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

func (*ElisionContext) GetParser 

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

func (*ElisionContext) GetRuleContext 

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

func (*ElisionContext) IsElisionContext 

func (*ElisionContext) IsElisionContext()

func (*ElisionContext) ToStringTree 

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

type EofContext 

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

func NewEmptyEofContext 

func NewEmptyEofContext() *EofContext

func NewEofContext 

func NewEofContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EofContext

func (*EofContext) EOF 

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

func (*EofContext) EnterRule 

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

func (*EofContext) ExitRule 

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

func (*EofContext) GetParser 

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

func (*EofContext) GetRuleContext 

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

func (*EofContext) IsEofContext 

func (*EofContext) IsEofContext()

func (*EofContext) ToStringTree 

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

type EosContext 

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

func NewEmptyEosContext 

func NewEmptyEosContext() *EosContext

func NewEosContext 

func NewEosContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EosContext

func (*EosContext) EOF 

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

func (*EosContext) EnterRule 

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

func (*EosContext) ExitRule 

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

func (*EosContext) GetParser 

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

func (*EosContext) GetRuleContext 

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

func (*EosContext) IsEosContext 

func (*EosContext) IsEosContext()

func (*EosContext) SemiColon 

func (s *EosContext) SemiColon() antlr.TerminalNode

func (*EosContext) ToStringTree 

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

type EqualityExpressionContext 

type EqualityExpressionContext struct {
	*SingleExpressionContext
}

func NewEqualityExpressionContext 

func NewEqualityExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityExpressionContext

func (*EqualityExpressionContext) AllSingleExpression 

func (s *EqualityExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*EqualityExpressionContext) EnterRule 

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

func (*EqualityExpressionContext) Equals 

func (s *EqualityExpressionContext) Equals() antlr.TerminalNode

func (*EqualityExpressionContext) ExitRule 

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

func (*EqualityExpressionContext) GetRuleContext 

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

func (*EqualityExpressionContext) IdentityEquals 

func (s *EqualityExpressionContext) IdentityEquals() antlr.TerminalNode

func (*EqualityExpressionContext) IdentityNotEquals 

func (s *EqualityExpressionContext) IdentityNotEquals() antlr.TerminalNode

func (*EqualityExpressionContext) NotEquals 

func (s *EqualityExpressionContext) NotEquals() antlr.TerminalNode

func (*EqualityExpressionContext) SingleExpression 

func (s *EqualityExpressionContext) SingleExpression(i int) ISingleExpressionContext

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

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

func (*ExpressionSequenceContext) AllSingleExpression 

func (s *ExpressionSequenceContext) AllSingleExpression() []ISingleExpressionContext

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

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

func (*ExpressionSequenceContext) GetRuleContext 

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

func (*ExpressionSequenceContext) IsExpressionSequenceContext 

func (*ExpressionSequenceContext) IsExpressionSequenceContext()

func (*ExpressionSequenceContext) SingleExpression 

func (s *ExpressionSequenceContext) SingleExpression(i int) ISingleExpressionContext

func (*ExpressionSequenceContext) ToStringTree 

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

type ExpressionStatementContext 

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

func NewEmptyExpressionStatementContext 

func NewEmptyExpressionStatementContext() *ExpressionStatementContext

func NewExpressionStatementContext 

func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext

func (*ExpressionStatementContext) EnterRule 

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

func (*ExpressionStatementContext) Eos 

func (s *ExpressionStatementContext) Eos() IEosContext

func (*ExpressionStatementContext) ExitRule 

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

func (*ExpressionStatementContext) ExpressionSequence 

func (s *ExpressionStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ExpressionStatementContext) GetParser 

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

func (*ExpressionStatementContext) GetRuleContext 

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

func (*ExpressionStatementContext) IsExpressionStatementContext 

func (*ExpressionStatementContext) IsExpressionStatementContext()

func (*ExpressionStatementContext) ToStringTree 

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

type FinallyProductionContext 

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

func NewEmptyFinallyProductionContext 

func NewEmptyFinallyProductionContext() *FinallyProductionContext

func NewFinallyProductionContext 

func NewFinallyProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyProductionContext

func (*FinallyProductionContext) Block 

func (s *FinallyProductionContext) Block() IBlockContext

func (*FinallyProductionContext) EnterRule 

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

func (*FinallyProductionContext) ExitRule 

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

func (*FinallyProductionContext) Finally 

func (s *FinallyProductionContext) Finally() antlr.TerminalNode

func (*FinallyProductionContext) GetParser 

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

func (*FinallyProductionContext) GetRuleContext 

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

func (*FinallyProductionContext) IsFinallyProductionContext 

func (*FinallyProductionContext) IsFinallyProductionContext()

func (*FinallyProductionContext) ToStringTree 

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

type ForInStatementContext 

type ForInStatementContext struct {
	*IterationStatementContext
}

func NewForInStatementContext 

func NewForInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForInStatementContext

func (*ForInStatementContext) CloseParen 

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

func (*ForInStatementContext) EnterRule 

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

func (*ForInStatementContext) ExitRule 

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

func (*ForInStatementContext) ExpressionSequence 

func (s *ForInStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ForInStatementContext) For 

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

func (*ForInStatementContext) GetRuleContext 

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

func (*ForInStatementContext) In 

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

func (*ForInStatementContext) OpenParen 

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

func (*ForInStatementContext) SingleExpression 

func (s *ForInStatementContext) SingleExpression() ISingleExpressionContext

func (*ForInStatementContext) Statement 

func (s *ForInStatementContext) Statement() IStatementContext

type ForStatementContext 

type ForStatementContext struct {
	*IterationStatementContext
}

func NewForStatementContext 

func NewForStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForStatementContext

func (*ForStatementContext) AllExpressionSequence 

func (s *ForStatementContext) AllExpressionSequence() []IExpressionSequenceContext

func (*ForStatementContext) AllSemiColon 

func (s *ForStatementContext) AllSemiColon() []antlr.TerminalNode

func (*ForStatementContext) CloseParen 

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

func (*ForStatementContext) EnterRule 

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

func (*ForStatementContext) ExitRule 

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

func (*ForStatementContext) ExpressionSequence 

func (s *ForStatementContext) ExpressionSequence(i int) IExpressionSequenceContext

func (*ForStatementContext) For 

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

func (*ForStatementContext) GetRuleContext 

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

func (*ForStatementContext) OpenParen 

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

func (*ForStatementContext) SemiColon 

func (s *ForStatementContext) SemiColon(i int) antlr.TerminalNode

func (*ForStatementContext) Statement 

func (s *ForStatementContext) Statement() IStatementContext

type ForVarInStatementContext 

type ForVarInStatementContext struct {
	*IterationStatementContext
}

func NewForVarInStatementContext 

func NewForVarInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForVarInStatementContext

func (*ForVarInStatementContext) CloseParen 

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

func (*ForVarInStatementContext) EnterRule 

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

func (*ForVarInStatementContext) ExitRule 

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

func (*ForVarInStatementContext) ExpressionSequence 

func (s *ForVarInStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ForVarInStatementContext) For 

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

func (*ForVarInStatementContext) GetRuleContext 

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

func (*ForVarInStatementContext) In 

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

func (*ForVarInStatementContext) OpenParen 

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

func (*ForVarInStatementContext) Statement 

func (s *ForVarInStatementContext) Statement() IStatementContext

func (*ForVarInStatementContext) Var 

func (s *ForVarInStatementContext) Var() antlr.TerminalNode

func (*ForVarInStatementContext) VariableDeclaration 

func (s *ForVarInStatementContext) VariableDeclaration() IVariableDeclarationContext

type ForVarStatementContext 

type ForVarStatementContext struct {
	*IterationStatementContext
}

func NewForVarStatementContext 

func NewForVarStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForVarStatementContext

func (*ForVarStatementContext) AllExpressionSequence 

func (s *ForVarStatementContext) AllExpressionSequence() []IExpressionSequenceContext

func (*ForVarStatementContext) AllSemiColon 

func (s *ForVarStatementContext) AllSemiColon() []antlr.TerminalNode

func (*ForVarStatementContext) CloseParen 

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

func (*ForVarStatementContext) EnterRule 

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

func (*ForVarStatementContext) ExitRule 

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

func (*ForVarStatementContext) ExpressionSequence 

func (s *ForVarStatementContext) ExpressionSequence(i int) IExpressionSequenceContext

func (*ForVarStatementContext) For 

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

func (*ForVarStatementContext) GetRuleContext 

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

func (*ForVarStatementContext) OpenParen 

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

func (*ForVarStatementContext) SemiColon 

func (s *ForVarStatementContext) SemiColon(i int) antlr.TerminalNode

func (*ForVarStatementContext) Statement 

func (s *ForVarStatementContext) Statement() IStatementContext

func (*ForVarStatementContext) Var 

func (s *ForVarStatementContext) Var() antlr.TerminalNode

func (*ForVarStatementContext) VariableDeclarationList 

func (s *ForVarStatementContext) VariableDeclarationList() IVariableDeclarationListContext

type FormalParameterListContext 

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

func NewEmptyFormalParameterListContext 

func NewEmptyFormalParameterListContext() *FormalParameterListContext

func NewFormalParameterListContext 

func NewFormalParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterListContext

func (*FormalParameterListContext) AllComma 

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

func (*FormalParameterListContext) AllIdentifier 

func (s *FormalParameterListContext) AllIdentifier() []antlr.TerminalNode

func (*FormalParameterListContext) Comma 

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

func (*FormalParameterListContext) EnterRule 

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

func (*FormalParameterListContext) ExitRule 

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

func (*FormalParameterListContext) GetParser 

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

func (*FormalParameterListContext) GetRuleContext 

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

func (*FormalParameterListContext) Identifier 

func (s *FormalParameterListContext) Identifier(i int) antlr.TerminalNode

func (*FormalParameterListContext) IsFormalParameterListContext 

func (*FormalParameterListContext) IsFormalParameterListContext()

func (*FormalParameterListContext) ToStringTree 

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

type FunctionBodyContext 

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

func NewEmptyFunctionBodyContext 

func NewEmptyFunctionBodyContext() *FunctionBodyContext

func NewFunctionBodyContext 

func NewFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBodyContext

func (*FunctionBodyContext) EnterRule 

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

func (*FunctionBodyContext) ExitRule 

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

func (*FunctionBodyContext) GetParser 

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

func (*FunctionBodyContext) GetRuleContext 

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

func (*FunctionBodyContext) IsFunctionBodyContext 

func (*FunctionBodyContext) IsFunctionBodyContext()

func (*FunctionBodyContext) SourceElements 

func (s *FunctionBodyContext) SourceElements() ISourceElementsContext

func (*FunctionBodyContext) ToStringTree 

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

type FunctionDeclarationContext 

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

func NewEmptyFunctionDeclarationContext 

func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext

func NewFunctionDeclarationContext 

func NewFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationContext

func (*FunctionDeclarationContext) CloseBrace 

func (s *FunctionDeclarationContext) CloseBrace() antlr.TerminalNode

func (*FunctionDeclarationContext) CloseParen 

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

func (*FunctionDeclarationContext) EnterRule 

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

func (*FunctionDeclarationContext) ExitRule 

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

func (*FunctionDeclarationContext) FormalParameterList 

func (s *FunctionDeclarationContext) FormalParameterList() IFormalParameterListContext

func (*FunctionDeclarationContext) Function 

func (s *FunctionDeclarationContext) Function() antlr.TerminalNode

func (*FunctionDeclarationContext) FunctionBody 

func (s *FunctionDeclarationContext) FunctionBody() IFunctionBodyContext

func (*FunctionDeclarationContext) GetParser 

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

func (*FunctionDeclarationContext) GetRuleContext 

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

func (*FunctionDeclarationContext) Identifier 

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

func (*FunctionDeclarationContext) IsFunctionDeclarationContext 

func (*FunctionDeclarationContext) IsFunctionDeclarationContext()

func (*FunctionDeclarationContext) OpenBrace 

func (s *FunctionDeclarationContext) OpenBrace() antlr.TerminalNode

func (*FunctionDeclarationContext) OpenParen 

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

func (*FunctionDeclarationContext) ToStringTree 

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

type FunctionExpressionContext 

type FunctionExpressionContext struct {
	*SingleExpressionContext
}

func NewFunctionExpressionContext 

func NewFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionExpressionContext

func (*FunctionExpressionContext) CloseBrace 

func (s *FunctionExpressionContext) CloseBrace() antlr.TerminalNode

func (*FunctionExpressionContext) CloseParen 

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

func (*FunctionExpressionContext) EnterRule 

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

func (*FunctionExpressionContext) ExitRule 

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

func (*FunctionExpressionContext) FormalParameterList 

func (s *FunctionExpressionContext) FormalParameterList() IFormalParameterListContext

func (*FunctionExpressionContext) Function 

func (s *FunctionExpressionContext) Function() antlr.TerminalNode

func (*FunctionExpressionContext) FunctionBody 

func (s *FunctionExpressionContext) FunctionBody() IFunctionBodyContext

func (*FunctionExpressionContext) GetRuleContext 

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

func (*FunctionExpressionContext) Identifier 

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

func (*FunctionExpressionContext) OpenBrace 

func (s *FunctionExpressionContext) OpenBrace() antlr.TerminalNode

func (*FunctionExpressionContext) OpenParen 

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

type FutureReservedWordContext 

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

func NewEmptyFutureReservedWordContext 

func NewEmptyFutureReservedWordContext() *FutureReservedWordContext

func NewFutureReservedWordContext 

func NewFutureReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FutureReservedWordContext

func (*FutureReservedWordContext) Class 

func (s *FutureReservedWordContext) Class() antlr.TerminalNode

func (*FutureReservedWordContext) Const 

func (s *FutureReservedWordContext) Const() antlr.TerminalNode

func (*FutureReservedWordContext) EnterRule 

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

func (*FutureReservedWordContext) Enum 

func (s *FutureReservedWordContext) Enum() antlr.TerminalNode

func (*FutureReservedWordContext) ExitRule 

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

func (*FutureReservedWordContext) Export 

func (s *FutureReservedWordContext) Export() antlr.TerminalNode

func (*FutureReservedWordContext) Extends 

func (s *FutureReservedWordContext) Extends() antlr.TerminalNode

func (*FutureReservedWordContext) GetParser 

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

func (*FutureReservedWordContext) GetRuleContext 

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

func (*FutureReservedWordContext) Implements 

func (s *FutureReservedWordContext) Implements() antlr.TerminalNode

func (*FutureReservedWordContext) Import 

func (s *FutureReservedWordContext) Import() antlr.TerminalNode

func (*FutureReservedWordContext) Interface 

func (s *FutureReservedWordContext) Interface() antlr.TerminalNode

func (*FutureReservedWordContext) IsFutureReservedWordContext 

func (*FutureReservedWordContext) IsFutureReservedWordContext()

func (*FutureReservedWordContext) Let 

func (s *FutureReservedWordContext) Let() antlr.TerminalNode

func (*FutureReservedWordContext) Package 

func (s *FutureReservedWordContext) Package() antlr.TerminalNode

func (*FutureReservedWordContext) Private 

func (s *FutureReservedWordContext) Private() antlr.TerminalNode

func (*FutureReservedWordContext) Protected 

func (s *FutureReservedWordContext) Protected() antlr.TerminalNode

func (*FutureReservedWordContext) Public 

func (s *FutureReservedWordContext) Public() antlr.TerminalNode

func (*FutureReservedWordContext) Static 

func (s *FutureReservedWordContext) Static() antlr.TerminalNode

func (*FutureReservedWordContext) Super 

func (s *FutureReservedWordContext) Super() antlr.TerminalNode

func (*FutureReservedWordContext) ToStringTree 

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

func (*FutureReservedWordContext) Yield 

func (s *FutureReservedWordContext) Yield() antlr.TerminalNode

type GetterContext 

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

func NewEmptyGetterContext 

func NewEmptyGetterContext() *GetterContext

func NewGetterContext 

func NewGetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetterContext

func (*GetterContext) EnterRule 

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

func (*GetterContext) ExitRule 

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

func (*GetterContext) GetParser 

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

func (*GetterContext) GetRuleContext 

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

func (*GetterContext) Identifier 

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

func (*GetterContext) IsGetterContext 

func (*GetterContext) IsGetterContext()

func (*GetterContext) PropertyName 

func (s *GetterContext) PropertyName() IPropertyNameContext

func (*GetterContext) ToStringTree 

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

type IArgumentListContext 

type IArgumentListContext interface {
	antlr.ParserRuleContext

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

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

IArgumentListContext is an interface to support dynamic dispatch.

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

type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

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

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

IAssignmentOperatorContext is an interface to support dynamic dispatch.

type IBlockContext 

type IBlockContext interface {
	antlr.ParserRuleContext

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

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

IBlockContext is an interface to support dynamic dispatch.

type IBreakStatementContext 

type IBreakStatementContext interface {
	antlr.ParserRuleContext

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

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

IBreakStatementContext is an interface to support dynamic dispatch.

type ICaseBlockContext 

type ICaseBlockContext interface {
	antlr.ParserRuleContext

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

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

ICaseBlockContext is an interface to support dynamic dispatch.

type ICaseClauseContext 

type ICaseClauseContext interface {
	antlr.ParserRuleContext

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

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

ICaseClauseContext is an interface to support dynamic dispatch.

type ICaseClausesContext 

type ICaseClausesContext interface {
	antlr.ParserRuleContext

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

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

ICaseClausesContext is an interface to support dynamic dispatch.

type ICatchProductionContext 

type ICatchProductionContext interface {
	antlr.ParserRuleContext

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

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

ICatchProductionContext is an interface to support dynamic dispatch.

type IContinueStatementContext 

type IContinueStatementContext interface {
	antlr.ParserRuleContext

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

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

IContinueStatementContext is an interface to support dynamic dispatch.

type IDebuggerStatementContext 

type IDebuggerStatementContext interface {
	antlr.ParserRuleContext

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

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

IDebuggerStatementContext is an interface to support dynamic dispatch.

type IDefaultClauseContext 

type IDefaultClauseContext interface {
	antlr.ParserRuleContext

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

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

IDefaultClauseContext is an interface to support dynamic dispatch.

type IElementListContext 

type IElementListContext interface {
	antlr.ParserRuleContext

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

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

IElementListContext is an interface to support dynamic dispatch.

type IElisionContext 

type IElisionContext interface {
	antlr.ParserRuleContext

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

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

IElisionContext is an interface to support dynamic dispatch.

type IEofContext 

type IEofContext interface {
	antlr.ParserRuleContext

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

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

IEofContext is an interface to support dynamic dispatch.

type IEosContext 

type IEosContext interface {
	antlr.ParserRuleContext

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

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

IEosContext 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 IExpressionStatementContext 

type IExpressionStatementContext interface {
	antlr.ParserRuleContext

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

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

IExpressionStatementContext is an interface to support dynamic dispatch.

type IFinallyProductionContext 

type IFinallyProductionContext interface {
	antlr.ParserRuleContext

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

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

IFinallyProductionContext is an interface to support dynamic dispatch.

type IFormalParameterListContext 

type IFormalParameterListContext interface {
	antlr.ParserRuleContext

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

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

IFormalParameterListContext is an interface to support dynamic dispatch.

type IFunctionBodyContext 

type IFunctionBodyContext interface {
	antlr.ParserRuleContext

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

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

IFunctionBodyContext is an interface to support dynamic dispatch.

type IFunctionDeclarationContext 

type IFunctionDeclarationContext interface {
	antlr.ParserRuleContext

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

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

IFunctionDeclarationContext is an interface to support dynamic dispatch.

type IFutureReservedWordContext 

type IFutureReservedWordContext interface {
	antlr.ParserRuleContext

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

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

IFutureReservedWordContext is an interface to support dynamic dispatch.

type IGetterContext 

type IGetterContext interface {
	antlr.ParserRuleContext

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

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

IGetterContext is an interface to support dynamic dispatch.

type IIdentifierNameContext 

type IIdentifierNameContext interface {
	antlr.ParserRuleContext

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

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

IIdentifierNameContext is an interface to support dynamic dispatch.

type IIfStatementContext 

type IIfStatementContext interface {
	antlr.ParserRuleContext

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

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

IIfStatementContext is an interface to support dynamic dispatch.

type IInitialiserContext 

type IInitialiserContext interface {
	antlr.ParserRuleContext

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

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

IInitialiserContext is an interface to support dynamic dispatch.

type IIterationStatementContext 

type IIterationStatementContext interface {
	antlr.ParserRuleContext

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

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

IIterationStatementContext is an interface to support dynamic dispatch.

type IKeywordContext 

type IKeywordContext interface {
	antlr.ParserRuleContext

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

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

IKeywordContext is an interface to support dynamic dispatch.

type ILabelledStatementContext 

type ILabelledStatementContext interface {
	antlr.ParserRuleContext

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

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

ILabelledStatementContext is an interface to support dynamic dispatch.

type ILiteralContext 

type ILiteralContext interface {
	antlr.ParserRuleContext

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

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

ILiteralContext is an interface to support dynamic dispatch.

type INumericLiteralContext 

type INumericLiteralContext interface {
	antlr.ParserRuleContext

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

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

INumericLiteralContext 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 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 IPropertyNameAndValueListContext 

type IPropertyNameAndValueListContext interface {
	antlr.ParserRuleContext

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

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

IPropertyNameAndValueListContext 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 IPropertySetParameterListContext 

type IPropertySetParameterListContext interface {
	antlr.ParserRuleContext

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

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

IPropertySetParameterListContext is an interface to support dynamic dispatch.

type IReservedWordContext 

type IReservedWordContext interface {
	antlr.ParserRuleContext

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

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

IReservedWordContext is an interface to support dynamic dispatch.

type IReturnStatementContext 

type IReturnStatementContext interface {
	antlr.ParserRuleContext

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

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

IReturnStatementContext is an interface to support dynamic dispatch.

type ISetterContext 

type ISetterContext interface {
	antlr.ParserRuleContext

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

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

ISetterContext is an interface to support dynamic dispatch.

type ISingleExpressionContext 

type ISingleExpressionContext interface {
	antlr.ParserRuleContext

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

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

ISingleExpressionContext is an interface to support dynamic dispatch.

type ISourceElementContext 

type ISourceElementContext interface {
	antlr.ParserRuleContext

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

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

ISourceElementContext is an interface to support dynamic dispatch.

type ISourceElementsContext 

type ISourceElementsContext interface {
	antlr.ParserRuleContext

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

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

ISourceElementsContext is an interface to support dynamic dispatch.

type IStatementContext 

type IStatementContext interface {
	antlr.ParserRuleContext

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

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

IStatementContext is an interface to support dynamic dispatch.

type IStatementListContext 

type IStatementListContext interface {
	antlr.ParserRuleContext

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

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

IStatementListContext is an interface to support dynamic dispatch.

type ISwitchStatementContext 

type ISwitchStatementContext interface {
	antlr.ParserRuleContext

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

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

ISwitchStatementContext is an interface to support dynamic dispatch.

type IThrowStatementContext 

type IThrowStatementContext interface {
	antlr.ParserRuleContext

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

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

IThrowStatementContext is an interface to support dynamic dispatch.

type ITryStatementContext 

type ITryStatementContext interface {
	antlr.ParserRuleContext

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

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

ITryStatementContext 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 IVariableDeclarationListContext 

type IVariableDeclarationListContext interface {
	antlr.ParserRuleContext

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

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

IVariableDeclarationListContext is an interface to support dynamic dispatch.

type IVariableStatementContext 

type IVariableStatementContext interface {
	antlr.ParserRuleContext

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

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

IVariableStatementContext is an interface to support dynamic dispatch.

type IVoidStatementContext 

type IVoidStatementContext interface {
	antlr.ParserRuleContext

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

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

IVoidStatementContext is an interface to support dynamic dispatch.

type IWithStatementContext 

type IWithStatementContext interface {
	antlr.ParserRuleContext

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

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

IWithStatementContext is an interface to support dynamic dispatch.

type IdentifierExpressionContext 

type IdentifierExpressionContext struct {
	*SingleExpressionContext
}

func NewIdentifierExpressionContext 

func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext

func (*IdentifierExpressionContext) EnterRule 

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

func (*IdentifierExpressionContext) ExitRule 

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

func (*IdentifierExpressionContext) GetRuleContext 

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

func (*IdentifierExpressionContext) Identifier 

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

type IdentifierNameContext 

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

func NewEmptyIdentifierNameContext 

func NewEmptyIdentifierNameContext() *IdentifierNameContext

func NewIdentifierNameContext 

func NewIdentifierNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierNameContext

func (*IdentifierNameContext) EnterRule 

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

func (*IdentifierNameContext) ExitRule 

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

func (*IdentifierNameContext) GetParser 

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

func (*IdentifierNameContext) GetRuleContext 

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

func (*IdentifierNameContext) Identifier 

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

func (*IdentifierNameContext) IsIdentifierNameContext 

func (*IdentifierNameContext) IsIdentifierNameContext()

func (*IdentifierNameContext) ReservedWord 

func (s *IdentifierNameContext) ReservedWord() IReservedWordContext

func (*IdentifierNameContext) ToStringTree 

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

type IfStatementContext 

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

func NewEmptyIfStatementContext 

func NewEmptyIfStatementContext() *IfStatementContext

func NewIfStatementContext 

func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext

func (*IfStatementContext) AllStatement 

func (s *IfStatementContext) AllStatement() []IStatementContext

func (*IfStatementContext) CloseParen 

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

func (*IfStatementContext) Else 

func (s *IfStatementContext) Else() antlr.TerminalNode

func (*IfStatementContext) EnterRule 

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

func (*IfStatementContext) ExitRule 

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

func (*IfStatementContext) ExpressionSequence 

func (s *IfStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*IfStatementContext) GetParser 

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

func (*IfStatementContext) GetRuleContext 

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

func (*IfStatementContext) If 

func (s *IfStatementContext) If() antlr.TerminalNode

func (*IfStatementContext) IsIfStatementContext 

func (*IfStatementContext) IsIfStatementContext()

func (*IfStatementContext) OpenParen 

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

func (*IfStatementContext) Statement 

func (s *IfStatementContext) Statement(i int) IStatementContext

func (*IfStatementContext) ToStringTree 

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

type InExpressionContext 

type InExpressionContext struct {
	*SingleExpressionContext
}

func NewInExpressionContext 

func NewInExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InExpressionContext

func (*InExpressionContext) AllSingleExpression 

func (s *InExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*InExpressionContext) EnterRule 

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

func (*InExpressionContext) ExitRule 

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

func (*InExpressionContext) GetRuleContext 

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

func (*InExpressionContext) In 

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

func (*InExpressionContext) SingleExpression 

func (s *InExpressionContext) SingleExpression(i int) ISingleExpressionContext

type InitialiserContext 

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

func NewEmptyInitialiserContext 

func NewEmptyInitialiserContext() *InitialiserContext

func NewInitialiserContext 

func NewInitialiserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitialiserContext

func (*InitialiserContext) Assign 

func (s *InitialiserContext) Assign() antlr.TerminalNode

func (*InitialiserContext) EnterRule 

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

func (*InitialiserContext) ExitRule 

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

func (*InitialiserContext) GetParser 

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

func (*InitialiserContext) GetRuleContext 

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

func (*InitialiserContext) IsInitialiserContext 

func (*InitialiserContext) IsInitialiserContext()

func (*InitialiserContext) SingleExpression 

func (s *InitialiserContext) SingleExpression() ISingleExpressionContext

func (*InitialiserContext) ToStringTree 

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

type InstanceofExpressionContext 

type InstanceofExpressionContext struct {
	*SingleExpressionContext
}

func NewInstanceofExpressionContext 

func NewInstanceofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InstanceofExpressionContext

func (*InstanceofExpressionContext) AllSingleExpression 

func (s *InstanceofExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*InstanceofExpressionContext) EnterRule 

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

func (*InstanceofExpressionContext) ExitRule 

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

func (*InstanceofExpressionContext) GetRuleContext 

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

func (*InstanceofExpressionContext) Instanceof 

func (s *InstanceofExpressionContext) Instanceof() antlr.TerminalNode

func (*InstanceofExpressionContext) SingleExpression 

func (s *InstanceofExpressionContext) SingleExpression(i int) ISingleExpressionContext

type IterationStatementContext 

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

func NewEmptyIterationStatementContext 

func NewEmptyIterationStatementContext() *IterationStatementContext

func NewIterationStatementContext 

func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext

func (*IterationStatementContext) CopyFrom 

func (s *IterationStatementContext) CopyFrom(ctx *IterationStatementContext)

func (*IterationStatementContext) GetParser 

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

func (*IterationStatementContext) GetRuleContext 

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

func (*IterationStatementContext) IsIterationStatementContext 

func (*IterationStatementContext) IsIterationStatementContext()

func (*IterationStatementContext) ToStringTree 

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

type KeywordContext 

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

func NewEmptyKeywordContext 

func NewEmptyKeywordContext() *KeywordContext

func NewKeywordContext 

func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext

func (*KeywordContext) Break 

func (s *KeywordContext) Break() antlr.TerminalNode

func (*KeywordContext) Case 

func (s *KeywordContext) Case() antlr.TerminalNode

func (*KeywordContext) Catch 

func (s *KeywordContext) Catch() antlr.TerminalNode

func (*KeywordContext) Continue 

func (s *KeywordContext) Continue() antlr.TerminalNode

func (*KeywordContext) Debugger 

func (s *KeywordContext) Debugger() antlr.TerminalNode

func (*KeywordContext) Default 

func (s *KeywordContext) Default() antlr.TerminalNode

func (*KeywordContext) Delete 

func (s *KeywordContext) Delete() antlr.TerminalNode

func (*KeywordContext) Do 

func (s *KeywordContext) Do() antlr.TerminalNode

func (*KeywordContext) Else 

func (s *KeywordContext) Else() antlr.TerminalNode

func (*KeywordContext) EnterRule 

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

func (*KeywordContext) ExitRule 

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

func (*KeywordContext) Finally 

func (s *KeywordContext) Finally() antlr.TerminalNode

func (*KeywordContext) For 

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

func (*KeywordContext) Function 

func (s *KeywordContext) Function() antlr.TerminalNode

func (*KeywordContext) GetParser 

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

func (*KeywordContext) GetRuleContext 

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

func (*KeywordContext) If 

func (s *KeywordContext) If() antlr.TerminalNode

func (*KeywordContext) In 

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

func (*KeywordContext) Instanceof 

func (s *KeywordContext) Instanceof() antlr.TerminalNode

func (*KeywordContext) IsKeywordContext 

func (*KeywordContext) IsKeywordContext()

func (*KeywordContext) New 

func (s *KeywordContext) New() antlr.TerminalNode

func (*KeywordContext) Return 

func (s *KeywordContext) Return() antlr.TerminalNode

func (*KeywordContext) Switch 

func (s *KeywordContext) Switch() antlr.TerminalNode

func (*KeywordContext) This 

func (s *KeywordContext) This() antlr.TerminalNode

func (*KeywordContext) Throw 

func (s *KeywordContext) Throw() antlr.TerminalNode

func (*KeywordContext) ToStringTree 

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

func (*KeywordContext) Try 

func (s *KeywordContext) Try() antlr.TerminalNode

func (*KeywordContext) Typeof 

func (s *KeywordContext) Typeof() antlr.TerminalNode

func (*KeywordContext) Var 

func (s *KeywordContext) Var() antlr.TerminalNode

func (*KeywordContext) Void 

func (s *KeywordContext) Void() antlr.TerminalNode

func (*KeywordContext) While 

func (s *KeywordContext) While() antlr.TerminalNode

func (*KeywordContext) With 

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

type LabelledStatementContext 

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

func NewEmptyLabelledStatementContext 

func NewEmptyLabelledStatementContext() *LabelledStatementContext

func NewLabelledStatementContext 

func NewLabelledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelledStatementContext

func (*LabelledStatementContext) Colon 

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

func (*LabelledStatementContext) EnterRule 

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

func (*LabelledStatementContext) ExitRule 

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

func (*LabelledStatementContext) GetParser 

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

func (*LabelledStatementContext) GetRuleContext 

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

func (*LabelledStatementContext) Identifier 

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

func (*LabelledStatementContext) IsLabelledStatementContext 

func (*LabelledStatementContext) IsLabelledStatementContext()

func (*LabelledStatementContext) Statement 

func (s *LabelledStatementContext) Statement() IStatementContext

func (*LabelledStatementContext) ToStringTree 

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

type LiteralContext 

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

func NewEmptyLiteralContext 

func NewEmptyLiteralContext() *LiteralContext

func NewLiteralContext 

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

func (*LiteralContext) BooleanLiteral 

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

func (*LiteralContext) EnterRule 

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

func (*LiteralContext) ExitRule 

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

func (*LiteralContext) GetParser 

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

func (*LiteralContext) GetRuleContext 

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

func (*LiteralContext) IsLiteralContext 

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) NullLiteral 

func (s *LiteralContext) NullLiteral() antlr.TerminalNode

func (*LiteralContext) NumericLiteral 

func (s *LiteralContext) NumericLiteral() INumericLiteralContext

func (*LiteralContext) RegularExpressionLiteral 

func (s *LiteralContext) RegularExpressionLiteral() antlr.TerminalNode

func (*LiteralContext) StringLiteral 

func (s *LiteralContext) StringLiteral() antlr.TerminalNode

func (*LiteralContext) ToStringTree 

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

type LiteralExpressionContext 

type LiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewLiteralExpressionContext 

func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext

func (*LiteralExpressionContext) EnterRule 

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

func (*LiteralExpressionContext) ExitRule 

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

func (*LiteralExpressionContext) GetRuleContext 

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

func (*LiteralExpressionContext) Literal 

func (s *LiteralExpressionContext) Literal() ILiteralContext

type LogicalAndExpressionContext 

type LogicalAndExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalAndExpressionContext 

func NewLogicalAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndExpressionContext

func (*LogicalAndExpressionContext) AllSingleExpression 

func (s *LogicalAndExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*LogicalAndExpressionContext) And 

func (s *LogicalAndExpressionContext) And() antlr.TerminalNode

func (*LogicalAndExpressionContext) EnterRule 

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

func (*LogicalAndExpressionContext) ExitRule 

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

func (*LogicalAndExpressionContext) GetRuleContext 

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

func (*LogicalAndExpressionContext) SingleExpression 

func (s *LogicalAndExpressionContext) SingleExpression(i int) ISingleExpressionContext

type LogicalOrExpressionContext 

type LogicalOrExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalOrExpressionContext 

func NewLogicalOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrExpressionContext

func (*LogicalOrExpressionContext) AllSingleExpression 

func (s *LogicalOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*LogicalOrExpressionContext) EnterRule 

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

func (*LogicalOrExpressionContext) ExitRule 

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

func (*LogicalOrExpressionContext) GetRuleContext 

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

func (*LogicalOrExpressionContext) Or 

func (s *LogicalOrExpressionContext) Or() antlr.TerminalNode

func (*LogicalOrExpressionContext) SingleExpression 

func (s *LogicalOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type MemberDotExpressionContext 

type MemberDotExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberDotExpressionContext 

func NewMemberDotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberDotExpressionContext

func (*MemberDotExpressionContext) Dot 

func (s *MemberDotExpressionContext) Dot() antlr.TerminalNode

func (*MemberDotExpressionContext) EnterRule 

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

func (*MemberDotExpressionContext) ExitRule 

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

func (*MemberDotExpressionContext) GetRuleContext 

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

func (*MemberDotExpressionContext) IdentifierName 

func (s *MemberDotExpressionContext) IdentifierName() IIdentifierNameContext

func (*MemberDotExpressionContext) SingleExpression 

func (s *MemberDotExpressionContext) SingleExpression() ISingleExpressionContext

type MemberIndexExpressionContext 

type MemberIndexExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberIndexExpressionContext 

func NewMemberIndexExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberIndexExpressionContext

func (*MemberIndexExpressionContext) CloseBracket 

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

func (*MemberIndexExpressionContext) EnterRule 

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

func (*MemberIndexExpressionContext) ExitRule 

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

func (*MemberIndexExpressionContext) ExpressionSequence 

func (s *MemberIndexExpressionContext) ExpressionSequence() IExpressionSequenceContext

func (*MemberIndexExpressionContext) GetRuleContext 

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

func (*MemberIndexExpressionContext) OpenBracket 

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

func (*MemberIndexExpressionContext) SingleExpression 

func (s *MemberIndexExpressionContext) SingleExpression() ISingleExpressionContext

type MultiplicativeExpressionContext 

type MultiplicativeExpressionContext struct {
	*SingleExpressionContext
}

func NewMultiplicativeExpressionContext 

func NewMultiplicativeExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicativeExpressionContext

func (*MultiplicativeExpressionContext) AllSingleExpression 

func (s *MultiplicativeExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*MultiplicativeExpressionContext) Divide 

func (s *MultiplicativeExpressionContext) Divide() antlr.TerminalNode

func (*MultiplicativeExpressionContext) EnterRule 

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

func (*MultiplicativeExpressionContext) ExitRule 

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

func (*MultiplicativeExpressionContext) GetRuleContext 

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

func (*MultiplicativeExpressionContext) Modulus 

func (s *MultiplicativeExpressionContext) Modulus() antlr.TerminalNode

func (*MultiplicativeExpressionContext) Multiply 

func (s *MultiplicativeExpressionContext) Multiply() antlr.TerminalNode

func (*MultiplicativeExpressionContext) SingleExpression 

func (s *MultiplicativeExpressionContext) SingleExpression(i int) ISingleExpressionContext

type NewExpressionContext 

type NewExpressionContext struct {
	*SingleExpressionContext
}

func NewNewExpressionContext 

func NewNewExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NewExpressionContext

func (*NewExpressionContext) Arguments 

func (s *NewExpressionContext) Arguments() IArgumentsContext

func (*NewExpressionContext) EnterRule 

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

func (*NewExpressionContext) ExitRule 

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

func (*NewExpressionContext) GetRuleContext 

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

func (*NewExpressionContext) New 

func (s *NewExpressionContext) New() antlr.TerminalNode

func (*NewExpressionContext) SingleExpression 

func (s *NewExpressionContext) SingleExpression() ISingleExpressionContext

type NotExpressionContext 

type NotExpressionContext struct {
	*SingleExpressionContext
}

func NewNotExpressionContext 

func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext

func (*NotExpressionContext) EnterRule 

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

func (*NotExpressionContext) ExitRule 

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

func (*NotExpressionContext) GetRuleContext 

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

func (*NotExpressionContext) Not 

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

func (*NotExpressionContext) SingleExpression 

func (s *NotExpressionContext) SingleExpression() ISingleExpressionContext

type NumericLiteralContext 

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

func NewEmptyNumericLiteralContext 

func NewEmptyNumericLiteralContext() *NumericLiteralContext

func NewNumericLiteralContext 

func NewNumericLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericLiteralContext

func (*NumericLiteralContext) DecimalLiteral 

func (s *NumericLiteralContext) DecimalLiteral() antlr.TerminalNode

func (*NumericLiteralContext) EnterRule 

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

func (*NumericLiteralContext) ExitRule 

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

func (*NumericLiteralContext) GetParser 

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

func (*NumericLiteralContext) GetRuleContext 

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

func (*NumericLiteralContext) HexIntegerLiteral 

func (s *NumericLiteralContext) HexIntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) IsNumericLiteralContext 

func (*NumericLiteralContext) IsNumericLiteralContext()

func (*NumericLiteralContext) OctalIntegerLiteral 

func (s *NumericLiteralContext) OctalIntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) ToStringTree 

func (s *NumericLiteralContext) 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) CloseBrace 

func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode

func (*ObjectLiteralContext) Comma 

func (s *ObjectLiteralContext) Comma() 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) PropertyNameAndValueList 

func (s *ObjectLiteralContext) PropertyNameAndValueList() IPropertyNameAndValueListContext

func (*ObjectLiteralContext) ToStringTree 

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

type ObjectLiteralExpressionContext 

type ObjectLiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewObjectLiteralExpressionContext 

func NewObjectLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectLiteralExpressionContext

func (*ObjectLiteralExpressionContext) EnterRule 

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

func (*ObjectLiteralExpressionContext) ExitRule 

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

func (*ObjectLiteralExpressionContext) GetRuleContext 

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

func (*ObjectLiteralExpressionContext) ObjectLiteral 

func (s *ObjectLiteralExpressionContext) ObjectLiteral() IObjectLiteralContext

type ParenthesizedExpressionContext 

type ParenthesizedExpressionContext struct {
	*SingleExpressionContext
}

func NewParenthesizedExpressionContext 

func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext

func (*ParenthesizedExpressionContext) CloseParen 

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

func (*ParenthesizedExpressionContext) EnterRule 

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

func (*ParenthesizedExpressionContext) ExitRule 

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

func (*ParenthesizedExpressionContext) ExpressionSequence 

func (s *ParenthesizedExpressionContext) ExpressionSequence() IExpressionSequenceContext

func (*ParenthesizedExpressionContext) GetRuleContext 

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

func (*ParenthesizedExpressionContext) OpenParen 

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

type PostDecreaseExpressionContext 

type PostDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPostDecreaseExpressionContext 

func NewPostDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostDecreaseExpressionContext

func (*PostDecreaseExpressionContext) EnterRule 

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

func (*PostDecreaseExpressionContext) ExitRule 

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

func (*PostDecreaseExpressionContext) GetRuleContext 

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

func (*PostDecreaseExpressionContext) MinusMinus 

func (s *PostDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PostDecreaseExpressionContext) SingleExpression 

func (s *PostDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PostIncrementExpressionContext 

type PostIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPostIncrementExpressionContext 

func NewPostIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostIncrementExpressionContext

func (*PostIncrementExpressionContext) EnterRule 

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

func (*PostIncrementExpressionContext) ExitRule 

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

func (*PostIncrementExpressionContext) GetRuleContext 

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

func (*PostIncrementExpressionContext) PlusPlus 

func (s *PostIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PostIncrementExpressionContext) SingleExpression 

func (s *PostIncrementExpressionContext) SingleExpression() ISingleExpressionContext

type PreDecreaseExpressionContext 

type PreDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPreDecreaseExpressionContext 

func NewPreDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreDecreaseExpressionContext

func (*PreDecreaseExpressionContext) EnterRule 

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

func (*PreDecreaseExpressionContext) ExitRule 

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

func (*PreDecreaseExpressionContext) GetRuleContext 

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

func (*PreDecreaseExpressionContext) MinusMinus 

func (s *PreDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PreDecreaseExpressionContext) SingleExpression 

func (s *PreDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PreIncrementExpressionContext 

type PreIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPreIncrementExpressionContext 

func NewPreIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreIncrementExpressionContext

func (*PreIncrementExpressionContext) EnterRule 

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

func (*PreIncrementExpressionContext) ExitRule 

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

func (*PreIncrementExpressionContext) GetRuleContext 

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

func (*PreIncrementExpressionContext) PlusPlus 

func (s *PreIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PreIncrementExpressionContext) SingleExpression 

func (s *PreIncrementExpressionContext) SingleExpression() ISingleExpressionContext

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

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

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

func (s *ProgramContext) SourceElements() ISourceElementsContext

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

func (s *PropertyAssignmentContext) CopyFrom(ctx *PropertyAssignmentContext)

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

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

type PropertyExpressionAssignmentContext 

type PropertyExpressionAssignmentContext struct {
	*PropertyAssignmentContext
}

func NewPropertyExpressionAssignmentContext 

func NewPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyExpressionAssignmentContext

func (*PropertyExpressionAssignmentContext) Colon 

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

func (*PropertyExpressionAssignmentContext) EnterRule 

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

func (*PropertyExpressionAssignmentContext) ExitRule 

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

func (*PropertyExpressionAssignmentContext) GetRuleContext 

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

func (*PropertyExpressionAssignmentContext) PropertyName 

func (s *PropertyExpressionAssignmentContext) PropertyName() IPropertyNameContext

func (*PropertyExpressionAssignmentContext) SingleExpression 

func (s *PropertyExpressionAssignmentContext) SingleExpression() ISingleExpressionContext

type PropertyGetterContext 

type PropertyGetterContext struct {
	*PropertyAssignmentContext
}

func NewPropertyGetterContext 

func NewPropertyGetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyGetterContext

func (*PropertyGetterContext) CloseBrace 

func (s *PropertyGetterContext) CloseBrace() antlr.TerminalNode

func (*PropertyGetterContext) CloseParen 

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

func (*PropertyGetterContext) EnterRule 

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

func (*PropertyGetterContext) ExitRule 

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

func (*PropertyGetterContext) FunctionBody 

func (s *PropertyGetterContext) FunctionBody() IFunctionBodyContext

func (*PropertyGetterContext) GetRuleContext 

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

func (*PropertyGetterContext) Getter 

func (s *PropertyGetterContext) Getter() IGetterContext

func (*PropertyGetterContext) OpenBrace 

func (s *PropertyGetterContext) OpenBrace() antlr.TerminalNode

func (*PropertyGetterContext) OpenParen 

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

type PropertyNameAndValueListContext 

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

func NewEmptyPropertyNameAndValueListContext 

func NewEmptyPropertyNameAndValueListContext() *PropertyNameAndValueListContext

func NewPropertyNameAndValueListContext 

func NewPropertyNameAndValueListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameAndValueListContext

func (*PropertyNameAndValueListContext) AllComma 

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

func (*PropertyNameAndValueListContext) AllPropertyAssignment 

func (s *PropertyNameAndValueListContext) AllPropertyAssignment() []IPropertyAssignmentContext

func (*PropertyNameAndValueListContext) Comma 

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

func (*PropertyNameAndValueListContext) EnterRule 

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

func (*PropertyNameAndValueListContext) ExitRule 

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

func (*PropertyNameAndValueListContext) GetParser 

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

func (*PropertyNameAndValueListContext) GetRuleContext 

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

func (*PropertyNameAndValueListContext) IsPropertyNameAndValueListContext 

func (*PropertyNameAndValueListContext) IsPropertyNameAndValueListContext()

func (*PropertyNameAndValueListContext) PropertyAssignment 

func (s *PropertyNameAndValueListContext) PropertyAssignment(i int) IPropertyAssignmentContext

func (*PropertyNameAndValueListContext) ToStringTree 

func (s *PropertyNameAndValueListContext) 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) 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) IdentifierName 

func (s *PropertyNameContext) IdentifierName() IIdentifierNameContext

func (*PropertyNameContext) IsPropertyNameContext 

func (*PropertyNameContext) IsPropertyNameContext()

func (*PropertyNameContext) NumericLiteral 

func (s *PropertyNameContext) NumericLiteral() INumericLiteralContext

func (*PropertyNameContext) StringLiteral 

func (s *PropertyNameContext) StringLiteral() antlr.TerminalNode

func (*PropertyNameContext) ToStringTree 

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

type PropertySetParameterListContext 

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

func NewEmptyPropertySetParameterListContext 

func NewEmptyPropertySetParameterListContext() *PropertySetParameterListContext

func NewPropertySetParameterListContext 

func NewPropertySetParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertySetParameterListContext

func (*PropertySetParameterListContext) EnterRule 

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

func (*PropertySetParameterListContext) ExitRule 

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

func (*PropertySetParameterListContext) GetParser 

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

func (*PropertySetParameterListContext) GetRuleContext 

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

func (*PropertySetParameterListContext) Identifier 

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

func (*PropertySetParameterListContext) IsPropertySetParameterListContext 

func (*PropertySetParameterListContext) IsPropertySetParameterListContext()

func (*PropertySetParameterListContext) ToStringTree 

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

type PropertySetterContext 

type PropertySetterContext struct {
	*PropertyAssignmentContext
}

func NewPropertySetterContext 

func NewPropertySetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertySetterContext

func (*PropertySetterContext) CloseBrace 

func (s *PropertySetterContext) CloseBrace() antlr.TerminalNode

func (*PropertySetterContext) CloseParen 

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

func (*PropertySetterContext) EnterRule 

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

func (*PropertySetterContext) ExitRule 

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

func (*PropertySetterContext) FunctionBody 

func (s *PropertySetterContext) FunctionBody() IFunctionBodyContext

func (*PropertySetterContext) GetRuleContext 

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

func (*PropertySetterContext) OpenBrace 

func (s *PropertySetterContext) OpenBrace() antlr.TerminalNode

func (*PropertySetterContext) OpenParen 

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

func (*PropertySetterContext) PropertySetParameterList 

func (s *PropertySetterContext) PropertySetParameterList() IPropertySetParameterListContext

func (*PropertySetterContext) Setter 

func (s *PropertySetterContext) Setter() ISetterContext

type RelationalExpressionContext 

type RelationalExpressionContext struct {
	*SingleExpressionContext
}

func NewRelationalExpressionContext 

func NewRelationalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalExpressionContext

func (*RelationalExpressionContext) AllSingleExpression 

func (s *RelationalExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*RelationalExpressionContext) EnterRule 

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

func (*RelationalExpressionContext) ExitRule 

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

func (*RelationalExpressionContext) GetRuleContext 

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

func (*RelationalExpressionContext) GreaterThanEquals 

func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) LessThan 

func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode

func (*RelationalExpressionContext) LessThanEquals 

func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) MoreThan 

func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode

func (*RelationalExpressionContext) SingleExpression 

func (s *RelationalExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ReservedWordContext 

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

func NewEmptyReservedWordContext 

func NewEmptyReservedWordContext() *ReservedWordContext

func NewReservedWordContext 

func NewReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReservedWordContext

func (*ReservedWordContext) BooleanLiteral 

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

func (*ReservedWordContext) EnterRule 

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

func (*ReservedWordContext) ExitRule 

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

func (*ReservedWordContext) FutureReservedWord 

func (s *ReservedWordContext) FutureReservedWord() IFutureReservedWordContext

func (*ReservedWordContext) GetParser 

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

func (*ReservedWordContext) GetRuleContext 

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

func (*ReservedWordContext) IsReservedWordContext 

func (*ReservedWordContext) IsReservedWordContext()

func (*ReservedWordContext) Keyword 

func (s *ReservedWordContext) Keyword() IKeywordContext

func (*ReservedWordContext) NullLiteral 

func (s *ReservedWordContext) NullLiteral() antlr.TerminalNode

func (*ReservedWordContext) ToStringTree 

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

type ReturnStatementContext 

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

func NewEmptyReturnStatementContext 

func NewEmptyReturnStatementContext() *ReturnStatementContext

func NewReturnStatementContext 

func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext

func (*ReturnStatementContext) EnterRule 

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

func (*ReturnStatementContext) Eos 

func (s *ReturnStatementContext) Eos() IEosContext

func (*ReturnStatementContext) ExitRule 

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

func (*ReturnStatementContext) ExpressionSequence 

func (s *ReturnStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ReturnStatementContext) GetParser 

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

func (*ReturnStatementContext) GetRuleContext 

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

func (*ReturnStatementContext) IsReturnStatementContext 

func (*ReturnStatementContext) IsReturnStatementContext()

func (*ReturnStatementContext) Return 

func (s *ReturnStatementContext) Return() antlr.TerminalNode

func (*ReturnStatementContext) ToStringTree 

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

type SetterContext 

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

func NewEmptySetterContext 

func NewEmptySetterContext() *SetterContext

func NewSetterContext 

func NewSetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetterContext

func (*SetterContext) EnterRule 

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

func (*SetterContext) ExitRule 

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

func (*SetterContext) GetParser 

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

func (*SetterContext) GetRuleContext 

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

func (*SetterContext) Identifier 

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

func (*SetterContext) IsSetterContext 

func (*SetterContext) IsSetterContext()

func (*SetterContext) PropertyName 

func (s *SetterContext) PropertyName() IPropertyNameContext

func (*SetterContext) ToStringTree 

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

type SingleExpressionContext 

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

func NewEmptySingleExpressionContext 

func NewEmptySingleExpressionContext() *SingleExpressionContext

func NewSingleExpressionContext 

func NewSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleExpressionContext

func (*SingleExpressionContext) CopyFrom 

func (s *SingleExpressionContext) CopyFrom(ctx *SingleExpressionContext)

func (*SingleExpressionContext) GetParser 

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

func (*SingleExpressionContext) GetRuleContext 

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

func (*SingleExpressionContext) IsSingleExpressionContext 

func (*SingleExpressionContext) IsSingleExpressionContext()

func (*SingleExpressionContext) ToStringTree 

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

type SourceElementContext 

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

func NewEmptySourceElementContext 

func NewEmptySourceElementContext() *SourceElementContext

func NewSourceElementContext 

func NewSourceElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementContext

func (*SourceElementContext) EnterRule 

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

func (*SourceElementContext) ExitRule 

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

func (*SourceElementContext) FunctionDeclaration 

func (s *SourceElementContext) FunctionDeclaration() IFunctionDeclarationContext

func (*SourceElementContext) GetParser 

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

func (*SourceElementContext) GetRuleContext 

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

func (*SourceElementContext) IsSourceElementContext 

func (*SourceElementContext) IsSourceElementContext()

func (*SourceElementContext) Statement 

func (s *SourceElementContext) Statement() IStatementContext

func (*SourceElementContext) ToStringTree 

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

type SourceElementsContext 

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

func NewEmptySourceElementsContext 

func NewEmptySourceElementsContext() *SourceElementsContext

func NewSourceElementsContext 

func NewSourceElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementsContext

func (*SourceElementsContext) AllSourceElement 

func (s *SourceElementsContext) AllSourceElement() []ISourceElementContext

func (*SourceElementsContext) EnterRule 

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

func (*SourceElementsContext) ExitRule 

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

func (*SourceElementsContext) GetParser 

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

func (*SourceElementsContext) GetRuleContext 

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

func (*SourceElementsContext) IsSourceElementsContext 

func (*SourceElementsContext) IsSourceElementsContext()

func (*SourceElementsContext) SourceElement 

func (s *SourceElementsContext) SourceElement(i int) ISourceElementContext

func (*SourceElementsContext) ToStringTree 

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

type StatementContext 

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

func NewEmptyStatementContext 

func NewEmptyStatementContext() *StatementContext

func NewStatementContext 

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

func (*StatementContext) Block 

func (s *StatementContext) Block() IBlockContext

func (*StatementContext) BreakStatement 

func (s *StatementContext) BreakStatement() IBreakStatementContext

func (*StatementContext) ContinueStatement 

func (s *StatementContext) ContinueStatement() IContinueStatementContext

func (*StatementContext) DebuggerStatement 

func (s *StatementContext) DebuggerStatement() IDebuggerStatementContext

func (*StatementContext) EnterRule 

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

func (*StatementContext) ExitRule 

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

func (*StatementContext) ExpressionStatement 

func (s *StatementContext) ExpressionStatement() IExpressionStatementContext

func (*StatementContext) GetParser 

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

func (*StatementContext) GetRuleContext 

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

func (*StatementContext) IfStatement 

func (s *StatementContext) IfStatement() IIfStatementContext

func (*StatementContext) IsStatementContext 

func (*StatementContext) IsStatementContext()

func (*StatementContext) IterationStatement 

func (s *StatementContext) IterationStatement() IIterationStatementContext

func (*StatementContext) LabelledStatement 

func (s *StatementContext) LabelledStatement() ILabelledStatementContext

func (*StatementContext) ReturnStatement 

func (s *StatementContext) ReturnStatement() IReturnStatementContext

func (*StatementContext) SwitchStatement 

func (s *StatementContext) SwitchStatement() ISwitchStatementContext

func (*StatementContext) ThrowStatement 

func (s *StatementContext) ThrowStatement() IThrowStatementContext

func (*StatementContext) ToStringTree 

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

func (*StatementContext) TryStatement 

func (s *StatementContext) TryStatement() ITryStatementContext

func (*StatementContext) VariableStatement 

func (s *StatementContext) VariableStatement() IVariableStatementContext

func (*StatementContext) VoidStatement 

func (s *StatementContext) VoidStatement() IVoidStatementContext

func (*StatementContext) WithStatement 

func (s *StatementContext) WithStatement() IWithStatementContext

type StatementListContext 

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

func NewEmptyStatementListContext 

func NewEmptyStatementListContext() *StatementListContext

func NewStatementListContext 

func NewStatementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementListContext

func (*StatementListContext) AllStatement 

func (s *StatementListContext) AllStatement() []IStatementContext

func (*StatementListContext) EnterRule 

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

func (*StatementListContext) ExitRule 

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

func (*StatementListContext) GetParser 

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

func (*StatementListContext) GetRuleContext 

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

func (*StatementListContext) IsStatementListContext 

func (*StatementListContext) IsStatementListContext()

func (*StatementListContext) Statement 

func (s *StatementListContext) Statement(i int) IStatementContext

func (*StatementListContext) ToStringTree 

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

type SwitchStatementContext 

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

func NewEmptySwitchStatementContext 

func NewEmptySwitchStatementContext() *SwitchStatementContext

func NewSwitchStatementContext 

func NewSwitchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchStatementContext

func (*SwitchStatementContext) CaseBlock 

func (s *SwitchStatementContext) CaseBlock() ICaseBlockContext

func (*SwitchStatementContext) CloseParen 

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

func (*SwitchStatementContext) EnterRule 

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

func (*SwitchStatementContext) ExitRule 

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

func (*SwitchStatementContext) ExpressionSequence 

func (s *SwitchStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*SwitchStatementContext) GetParser 

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

func (*SwitchStatementContext) GetRuleContext 

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

func (*SwitchStatementContext) IsSwitchStatementContext 

func (*SwitchStatementContext) IsSwitchStatementContext()

func (*SwitchStatementContext) OpenParen 

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

func (*SwitchStatementContext) Switch 

func (s *SwitchStatementContext) Switch() antlr.TerminalNode

func (*SwitchStatementContext) ToStringTree 

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

type TernaryExpressionContext 

type TernaryExpressionContext struct {
	*SingleExpressionContext
}

func NewTernaryExpressionContext 

func NewTernaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TernaryExpressionContext

func (*TernaryExpressionContext) AllSingleExpression 

func (s *TernaryExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*TernaryExpressionContext) Colon 

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

func (*TernaryExpressionContext) EnterRule 

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

func (*TernaryExpressionContext) ExitRule 

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

func (*TernaryExpressionContext) GetRuleContext 

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

func (*TernaryExpressionContext) QuestionMark 

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

func (*TernaryExpressionContext) SingleExpression 

func (s *TernaryExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ThisExpressionContext 

type ThisExpressionContext struct {
	*SingleExpressionContext
}

func NewThisExpressionContext 

func NewThisExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ThisExpressionContext

func (*ThisExpressionContext) EnterRule 

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

func (*ThisExpressionContext) ExitRule 

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

func (*ThisExpressionContext) GetRuleContext 

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

func (*ThisExpressionContext) This 

func (s *ThisExpressionContext) This() antlr.TerminalNode

type ThrowStatementContext 

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

func NewEmptyThrowStatementContext 

func NewEmptyThrowStatementContext() *ThrowStatementContext

func NewThrowStatementContext 

func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext

func (*ThrowStatementContext) EnterRule 

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

func (*ThrowStatementContext) Eos 

func (s *ThrowStatementContext) Eos() IEosContext

func (*ThrowStatementContext) ExitRule 

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

func (*ThrowStatementContext) ExpressionSequence 

func (s *ThrowStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ThrowStatementContext) GetParser 

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

func (*ThrowStatementContext) GetRuleContext 

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

func (*ThrowStatementContext) IsThrowStatementContext 

func (*ThrowStatementContext) IsThrowStatementContext()

func (*ThrowStatementContext) Throw 

func (s *ThrowStatementContext) Throw() antlr.TerminalNode

func (*ThrowStatementContext) ToStringTree 

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

type TryStatementContext 

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

func NewEmptyTryStatementContext 

func NewEmptyTryStatementContext() *TryStatementContext

func NewTryStatementContext 

func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext

func (*TryStatementContext) Block 

func (s *TryStatementContext) Block() IBlockContext

func (*TryStatementContext) CatchProduction 

func (s *TryStatementContext) CatchProduction() ICatchProductionContext

func (*TryStatementContext) EnterRule 

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

func (*TryStatementContext) ExitRule 

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

func (*TryStatementContext) FinallyProduction 

func (s *TryStatementContext) FinallyProduction() IFinallyProductionContext

func (*TryStatementContext) GetParser 

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

func (*TryStatementContext) GetRuleContext 

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

func (*TryStatementContext) IsTryStatementContext 

func (*TryStatementContext) IsTryStatementContext()

func (*TryStatementContext) ToStringTree 

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

func (*TryStatementContext) Try 

func (s *TryStatementContext) Try() antlr.TerminalNode

type TypeofExpressionContext 

type TypeofExpressionContext struct {
	*SingleExpressionContext
}

func NewTypeofExpressionContext 

func NewTypeofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeofExpressionContext

func (*TypeofExpressionContext) EnterRule 

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

func (*TypeofExpressionContext) ExitRule 

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

func (*TypeofExpressionContext) GetRuleContext 

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

func (*TypeofExpressionContext) SingleExpression 

func (s *TypeofExpressionContext) SingleExpression() ISingleExpressionContext

func (*TypeofExpressionContext) Typeof 

func (s *TypeofExpressionContext) Typeof() antlr.TerminalNode

type UnaryMinusExpressionContext 

type UnaryMinusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryMinusExpressionContext 

func NewUnaryMinusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryMinusExpressionContext

func (*UnaryMinusExpressionContext) EnterRule 

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

func (*UnaryMinusExpressionContext) ExitRule 

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

func (*UnaryMinusExpressionContext) GetRuleContext 

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

func (*UnaryMinusExpressionContext) Minus 

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

func (*UnaryMinusExpressionContext) SingleExpression 

func (s *UnaryMinusExpressionContext) SingleExpression() ISingleExpressionContext

type UnaryPlusExpressionContext 

type UnaryPlusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryPlusExpressionContext 

func NewUnaryPlusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryPlusExpressionContext

func (*UnaryPlusExpressionContext) EnterRule 

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

func (*UnaryPlusExpressionContext) ExitRule 

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

func (*UnaryPlusExpressionContext) GetRuleContext 

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

func (*UnaryPlusExpressionContext) Plus 

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

func (*UnaryPlusExpressionContext) SingleExpression 

func (s *UnaryPlusExpressionContext) SingleExpression() ISingleExpressionContext

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

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

func (*VariableDeclarationContext) ExitRule 

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

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

func (s *VariableDeclarationContext) Initialiser() IInitialiserContext

func (*VariableDeclarationContext) IsVariableDeclarationContext 

func (*VariableDeclarationContext) IsVariableDeclarationContext()

func (*VariableDeclarationContext) ToStringTree 

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

type VariableDeclarationListContext 

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

func NewEmptyVariableDeclarationListContext 

func NewEmptyVariableDeclarationListContext() *VariableDeclarationListContext

func NewVariableDeclarationListContext 

func NewVariableDeclarationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationListContext

func (*VariableDeclarationListContext) AllComma 

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

func (*VariableDeclarationListContext) AllVariableDeclaration 

func (s *VariableDeclarationListContext) AllVariableDeclaration() []IVariableDeclarationContext

func (*VariableDeclarationListContext) Comma 

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

func (*VariableDeclarationListContext) EnterRule 

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

func (*VariableDeclarationListContext) ExitRule 

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

func (*VariableDeclarationListContext) GetParser 

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

func (*VariableDeclarationListContext) GetRuleContext 

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

func (*VariableDeclarationListContext) IsVariableDeclarationListContext 

func (*VariableDeclarationListContext) IsVariableDeclarationListContext()

func (*VariableDeclarationListContext) ToStringTree 

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

func (*VariableDeclarationListContext) VariableDeclaration 

func (s *VariableDeclarationListContext) VariableDeclaration(i int) IVariableDeclarationContext

type VariableStatementContext 

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

func NewEmptyVariableStatementContext 

func NewEmptyVariableStatementContext() *VariableStatementContext

func NewVariableStatementContext 

func NewVariableStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableStatementContext

func (*VariableStatementContext) EnterRule 

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

func (*VariableStatementContext) Eos 

func (s *VariableStatementContext) Eos() IEosContext

func (*VariableStatementContext) ExitRule 

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

func (*VariableStatementContext) GetParser 

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

func (*VariableStatementContext) GetRuleContext 

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

func (*VariableStatementContext) IsVariableStatementContext 

func (*VariableStatementContext) IsVariableStatementContext()

func (*VariableStatementContext) ToStringTree 

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

func (*VariableStatementContext) Var 

func (s *VariableStatementContext) Var() antlr.TerminalNode

func (*VariableStatementContext) VariableDeclarationList 

func (s *VariableStatementContext) VariableDeclarationList() IVariableDeclarationListContext

type VoidExpressionContext 

type VoidExpressionContext struct {
	*SingleExpressionContext
}

func NewVoidExpressionContext 

func NewVoidExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VoidExpressionContext

func (*VoidExpressionContext) EnterRule 

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

func (*VoidExpressionContext) ExitRule 

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

func (*VoidExpressionContext) GetRuleContext 

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

func (*VoidExpressionContext) SingleExpression 

func (s *VoidExpressionContext) SingleExpression() ISingleExpressionContext

func (*VoidExpressionContext) Void 

func (s *VoidExpressionContext) Void() antlr.TerminalNode

type VoidStatementContext 

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

func NewEmptyVoidStatementContext 

func NewEmptyVoidStatementContext() *VoidStatementContext

func NewVoidStatementContext 

func NewVoidStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VoidStatementContext

func (*VoidStatementContext) EnterRule 

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

func (*VoidStatementContext) ExitRule 

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

func (*VoidStatementContext) GetParser 

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

func (*VoidStatementContext) GetRuleContext 

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

func (*VoidStatementContext) IsVoidStatementContext 

func (*VoidStatementContext) IsVoidStatementContext()

func (*VoidStatementContext) SemiColon 

func (s *VoidStatementContext) SemiColon() antlr.TerminalNode

func (*VoidStatementContext) ToStringTree 

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

type WhileStatementContext 

type WhileStatementContext struct {
	*IterationStatementContext
}

func NewWhileStatementContext 

func NewWhileStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhileStatementContext

func (*WhileStatementContext) CloseParen 

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

func (*WhileStatementContext) EnterRule 

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

func (*WhileStatementContext) ExitRule 

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

func (*WhileStatementContext) ExpressionSequence 

func (s *WhileStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*WhileStatementContext) GetRuleContext 

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

func (*WhileStatementContext) OpenParen 

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

func (*WhileStatementContext) Statement 

func (s *WhileStatementContext) Statement() IStatementContext

func (*WhileStatementContext) While 

func (s *WhileStatementContext) While() antlr.TerminalNode

type WithStatementContext 

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

func NewEmptyWithStatementContext 

func NewEmptyWithStatementContext() *WithStatementContext

func NewWithStatementContext 

func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext

func (*WithStatementContext) CloseParen 

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

func (*WithStatementContext) EnterRule 

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

func (*WithStatementContext) ExitRule 

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

func (*WithStatementContext) ExpressionSequence 

func (s *WithStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*WithStatementContext) GetParser 

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

func (*WithStatementContext) GetRuleContext 

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

func (*WithStatementContext) IsWithStatementContext 

func (*WithStatementContext) IsWithStatementContext()

func (*WithStatementContext) OpenParen 

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

func (*WithStatementContext) Statement 

func (s *WithStatementContext) Statement() IStatementContext

func (*WithStatementContext) ToStringTree 

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

func (*WithStatementContext) With 

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

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.