parser

package
v0.2.4 Latest Latest
Warning

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

 Go to latest Published: Jul 9, 2025 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	R2D2LexerT__0           = 1
	R2D2LexerUSE            = 2
	R2D2LexerIMPORT         = 3
	R2D2LexerFROM           = 4
	R2D2LexerINTERFACE      = 5
	R2D2LexerMODULE         = 6
	R2D2LexerIMPLEMENTS     = 7
	R2D2LexerEXPORT         = 8
	R2D2LexerFN             = 9
	R2D2LexerPSEUDO         = 10
	R2D2LexerVAR            = 11
	R2D2LexerLET            = 12
	R2D2LexerCONST          = 13
	R2D2LexerIF             = 14
	R2D2LexerELSE           = 15
	R2D2LexerLOOP           = 16
	R2D2LexerFOR            = 17
	R2D2LexerWHILE          = 18
	R2D2LexerBREAK          = 19
	R2D2LexerSEND           = 20
	R2D2LexerCONTINUE       = 21
	R2D2LexerRETURN         = 22
	R2D2LexerSWITCH         = 23
	R2D2LexerCASE           = 24
	R2D2LexerDEFAULT        = 25
	R2D2LexerARROW          = 26
	R2D2LexerINCREMENT      = 27
	R2D2LexerDECREMENT      = 28
	R2D2LexerPLUS_ASSIGN    = 29
	R2D2LexerMINUS_ASSIGN   = 30
	R2D2LexerMULT_ASSIGN    = 31
	R2D2LexerDIV_ASSIGN     = 32
	R2D2LexerMOD_ASSIGN     = 33
	R2D2LexerEQ             = 34
	R2D2LexerNEQ            = 35
	R2D2LexerLEQ            = 36
	R2D2LexerGEQ            = 37
	R2D2LexerAND            = 38
	R2D2LexerOR             = 39
	R2D2LexerPLUS           = 40
	R2D2LexerMINUS          = 41
	R2D2LexerMULT           = 42
	R2D2LexerDIV            = 43
	R2D2LexerMOD            = 44
	R2D2LexerASSIGN         = 45
	R2D2LexerLT             = 46
	R2D2LexerGT             = 47
	R2D2LexerNOT            = 48
	R2D2LexerLPAREN         = 49
	R2D2LexerRPAREN         = 50
	R2D2LexerLBRACE         = 51
	R2D2LexerRBRACE         = 52
	R2D2LexerLBRACK         = 53
	R2D2LexerRBRACK         = 54
	R2D2LexerCOMMA          = 55
	R2D2LexerDOT            = 56
	R2D2LexerCOLON          = 57
	R2D2LexerSEMI           = 58
	R2D2LexerAT             = 59
	R2D2LexerJS             = 60
	R2D2LexerTYPE           = 61
	R2D2LexerSTRING_LITERAL = 62
	R2D2LexerBOOL_LITERAL   = 63
	R2D2LexerNULL_LITERAL   = 64
	R2D2LexerINT_LITERAL    = 65
	R2D2LexerFLOAT_LITERAL  = 66
	R2D2LexerIDENTIFIER     = 67
	R2D2LexerCOMMENT        = 68
	R2D2LexerBLOCK_COMMENT  = 69
	R2D2LexerWHITESPACE     = 70
)

R2D2Lexer tokens.

View Source 
const (
	R2D2ParserEOF            = antlr.TokenEOF
	R2D2ParserT__0           = 1
	R2D2ParserUSE            = 2
	R2D2ParserIMPORT         = 3
	R2D2ParserFROM           = 4
	R2D2ParserINTERFACE      = 5
	R2D2ParserMODULE         = 6
	R2D2ParserIMPLEMENTS     = 7
	R2D2ParserEXPORT         = 8
	R2D2ParserFN             = 9
	R2D2ParserPSEUDO         = 10
	R2D2ParserVAR            = 11
	R2D2ParserLET            = 12
	R2D2ParserCONST          = 13
	R2D2ParserIF             = 14
	R2D2ParserELSE           = 15
	R2D2ParserLOOP           = 16
	R2D2ParserFOR            = 17
	R2D2ParserWHILE          = 18
	R2D2ParserBREAK          = 19
	R2D2ParserSEND           = 20
	R2D2ParserCONTINUE       = 21
	R2D2ParserRETURN         = 22
	R2D2ParserSWITCH         = 23
	R2D2ParserCASE           = 24
	R2D2ParserDEFAULT        = 25
	R2D2ParserARROW          = 26
	R2D2ParserINCREMENT      = 27
	R2D2ParserDECREMENT      = 28
	R2D2ParserPLUS_ASSIGN    = 29
	R2D2ParserMINUS_ASSIGN   = 30
	R2D2ParserMULT_ASSIGN    = 31
	R2D2ParserDIV_ASSIGN     = 32
	R2D2ParserMOD_ASSIGN     = 33
	R2D2ParserEQ             = 34
	R2D2ParserNEQ            = 35
	R2D2ParserLEQ            = 36
	R2D2ParserGEQ            = 37
	R2D2ParserAND            = 38
	R2D2ParserOR             = 39
	R2D2ParserPLUS           = 40
	R2D2ParserMINUS          = 41
	R2D2ParserMULT           = 42
	R2D2ParserDIV            = 43
	R2D2ParserMOD            = 44
	R2D2ParserASSIGN         = 45
	R2D2ParserLT             = 46
	R2D2ParserGT             = 47
	R2D2ParserNOT            = 48
	R2D2ParserLPAREN         = 49
	R2D2ParserRPAREN         = 50
	R2D2ParserLBRACE         = 51
	R2D2ParserRBRACE         = 52
	R2D2ParserLBRACK         = 53
	R2D2ParserRBRACK         = 54
	R2D2ParserCOMMA          = 55
	R2D2ParserDOT            = 56
	R2D2ParserCOLON          = 57
	R2D2ParserSEMI           = 58
	R2D2ParserAT             = 59
	R2D2ParserJS             = 60
	R2D2ParserTYPE           = 61
	R2D2ParserSTRING_LITERAL = 62
	R2D2ParserBOOL_LITERAL   = 63
	R2D2ParserNULL_LITERAL   = 64
	R2D2ParserINT_LITERAL    = 65
	R2D2ParserFLOAT_LITERAL  = 66
	R2D2ParserIDENTIFIER     = 67
	R2D2ParserCOMMENT        = 68
	R2D2ParserBLOCK_COMMENT  = 69
	R2D2ParserWHITESPACE     = 70
)

R2D2Parser tokens.

View Source 
const (
	R2D2ParserRULE_program               = 0
	R2D2ParserRULE_declaration           = 1
	R2D2ParserRULE_globalDeclaration     = 2
	R2D2ParserRULE_importDeclaration     = 3
	R2D2ParserRULE_interfaceDeclaration  = 4
	R2D2ParserRULE_moduleDeclaration     = 5
	R2D2ParserRULE_functionDeclaration   = 6
	R2D2ParserRULE_functionCallStatement = 7
	R2D2ParserRULE_functionCall          = 8
	R2D2ParserRULE_parameterList         = 9
	R2D2ParserRULE_parameter             = 10
	R2D2ParserRULE_typeExpression        = 11
	R2D2ParserRULE_arrayDimensions       = 12
	R2D2ParserRULE_baseType              = 13
	R2D2ParserRULE_genericType           = 14
	R2D2ParserRULE_typeDeclaration       = 15
	R2D2ParserRULE_variableDeclaration   = 16
	R2D2ParserRULE_statement             = 17
	R2D2ParserRULE_expressionStatement   = 18
	R2D2ParserRULE_ifStatement           = 19
	R2D2ParserRULE_forStatement          = 20
	R2D2ParserRULE_assignmentDeclaration = 21
	R2D2ParserRULE_assignment            = 22
	R2D2ParserRULE_assignmentOperator    = 23
	R2D2ParserRULE_simpleFor             = 24
	R2D2ParserRULE_whileStatement        = 25
	R2D2ParserRULE_loopStatement         = 26
	R2D2ParserRULE_cicleControl          = 27
	R2D2ParserRULE_breakStatement        = 28
	R2D2ParserRULE_continueStatement     = 29
	R2D2ParserRULE_returnStatement       = 30
	R2D2ParserRULE_expression            = 31
	R2D2ParserRULE_argumentList          = 32
	R2D2ParserRULE_objectLiteral         = 33
	R2D2ParserRULE_arrayLiteral          = 34
	R2D2ParserRULE_literal               = 35
	R2D2ParserRULE_block                 = 36
	R2D2ParserRULE_switchStatement       = 37
	R2D2ParserRULE_switchCase            = 38
	R2D2ParserRULE_defaultCase           = 39
	R2D2ParserRULE_jsStatement           = 40
)

R2D2Parser rules.

Variables

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

Functions

func InitEmptyArgumentListContext 

func InitEmptyArgumentListContext(p *ArgumentListContext)

func InitEmptyArrayDimensionsContext 

func InitEmptyArrayDimensionsContext(p *ArrayDimensionsContext)

func InitEmptyArrayLiteralContext 

func InitEmptyArrayLiteralContext(p *ArrayLiteralContext)

func InitEmptyAssignmentContext 

func InitEmptyAssignmentContext(p *AssignmentContext)

func InitEmptyAssignmentDeclarationContext 

func InitEmptyAssignmentDeclarationContext(p *AssignmentDeclarationContext)

func InitEmptyAssignmentOperatorContext 

func InitEmptyAssignmentOperatorContext(p *AssignmentOperatorContext)

func InitEmptyBaseTypeContext 

func InitEmptyBaseTypeContext(p *BaseTypeContext)

func InitEmptyBlockContext 

func InitEmptyBlockContext(p *BlockContext)

func InitEmptyBreakStatementContext 

func InitEmptyBreakStatementContext(p *BreakStatementContext)

func InitEmptyCicleControlContext 

func InitEmptyCicleControlContext(p *CicleControlContext)

func InitEmptyContinueStatementContext 

func InitEmptyContinueStatementContext(p *ContinueStatementContext)

func InitEmptyDeclarationContext 

func InitEmptyDeclarationContext(p *DeclarationContext)

func InitEmptyDefaultCaseContext 

func InitEmptyDefaultCaseContext(p *DefaultCaseContext)

func InitEmptyExpressionContext 

func InitEmptyExpressionContext(p *ExpressionContext)

func InitEmptyExpressionStatementContext 

func InitEmptyExpressionStatementContext(p *ExpressionStatementContext)

func InitEmptyForStatementContext 

func InitEmptyForStatementContext(p *ForStatementContext)

func InitEmptyFunctionCallContext 

func InitEmptyFunctionCallContext(p *FunctionCallContext)

func InitEmptyFunctionCallStatementContext 

func InitEmptyFunctionCallStatementContext(p *FunctionCallStatementContext)

func InitEmptyFunctionDeclarationContext 

func InitEmptyFunctionDeclarationContext(p *FunctionDeclarationContext)

func InitEmptyGenericTypeContext 

func InitEmptyGenericTypeContext(p *GenericTypeContext)

func InitEmptyGlobalDeclarationContext 

func InitEmptyGlobalDeclarationContext(p *GlobalDeclarationContext)

func InitEmptyIfStatementContext 

func InitEmptyIfStatementContext(p *IfStatementContext)

func InitEmptyImportDeclarationContext 

func InitEmptyImportDeclarationContext(p *ImportDeclarationContext)

func InitEmptyInterfaceDeclarationContext 

func InitEmptyInterfaceDeclarationContext(p *InterfaceDeclarationContext)

func InitEmptyJsStatementContext added in v0.1.1 

func InitEmptyJsStatementContext(p *JsStatementContext)

func InitEmptyLiteralContext 

func InitEmptyLiteralContext(p *LiteralContext)

func InitEmptyLoopStatementContext 

func InitEmptyLoopStatementContext(p *LoopStatementContext)

func InitEmptyModuleDeclarationContext 

func InitEmptyModuleDeclarationContext(p *ModuleDeclarationContext)

func InitEmptyObjectLiteralContext added in v0.2.2 

func InitEmptyObjectLiteralContext(p *ObjectLiteralContext)

func InitEmptyParameterContext 

func InitEmptyParameterContext(p *ParameterContext)

func InitEmptyParameterListContext 

func InitEmptyParameterListContext(p *ParameterListContext)

func InitEmptyProgramContext 

func InitEmptyProgramContext(p *ProgramContext)

func InitEmptyReturnStatementContext 

func InitEmptyReturnStatementContext(p *ReturnStatementContext)

func InitEmptySimpleForContext 

func InitEmptySimpleForContext(p *SimpleForContext)

func InitEmptyStatementContext 

func InitEmptyStatementContext(p *StatementContext)

func InitEmptySwitchCaseContext 

func InitEmptySwitchCaseContext(p *SwitchCaseContext)

func InitEmptySwitchStatementContext 

func InitEmptySwitchStatementContext(p *SwitchStatementContext)

func InitEmptyTypeDeclarationContext 

func InitEmptyTypeDeclarationContext(p *TypeDeclarationContext)

func InitEmptyTypeExpressionContext 

func InitEmptyTypeExpressionContext(p *TypeExpressionContext)

func InitEmptyVariableDeclarationContext 

func InitEmptyVariableDeclarationContext(p *VariableDeclarationContext)

func InitEmptyWhileStatementContext 

func InitEmptyWhileStatementContext(p *WhileStatementContext)

func R2D2LexerInit 

func R2D2LexerInit()

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

func R2D2ParserInit 

func R2D2ParserInit()

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

Types

type AdditiveExpressionContext 

type AdditiveExpressionContext struct {
	ExpressionContext
}

func NewAdditiveExpressionContext 

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

func (*AdditiveExpressionContext) Accept 

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

func (*AdditiveExpressionContext) AllExpression added in v0.1.1 

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

func (*AdditiveExpressionContext) EnterRule 

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

func (*AdditiveExpressionContext) ExitRule 

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

func (*AdditiveExpressionContext) Expression added in v0.1.1 

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

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

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

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

func (*ArgumentListContext) AllCOMMA 

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

func (*ArgumentListContext) AllExpression 

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

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

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

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

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

type ArrayAccessExpressionContext added in v0.1.1 

type ArrayAccessExpressionContext struct {
	ExpressionContext
}

func NewArrayAccessExpressionContext added in v0.1.1 

func NewArrayAccessExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayAccessExpressionContext

func (*ArrayAccessExpressionContext) Accept added in v0.1.1 

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

func (*ArrayAccessExpressionContext) AllExpression added in v0.1.1 

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

func (*ArrayAccessExpressionContext) EnterRule added in v0.1.1 

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

func (*ArrayAccessExpressionContext) ExitRule added in v0.1.1 

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

func (*ArrayAccessExpressionContext) Expression added in v0.1.1 

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

func (*ArrayAccessExpressionContext) GetRuleContext added in v0.1.1 

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

func (*ArrayAccessExpressionContext) LBRACK added in v0.1.1 

func (s *ArrayAccessExpressionContext) LBRACK() antlr.TerminalNode

func (*ArrayAccessExpressionContext) RBRACK added in v0.1.1 

func (s *ArrayAccessExpressionContext) RBRACK() antlr.TerminalNode

type ArrayDimensionsContext 

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

func NewArrayDimensionsContext 

func NewArrayDimensionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayDimensionsContext

func NewEmptyArrayDimensionsContext 

func NewEmptyArrayDimensionsContext() *ArrayDimensionsContext

func (*ArrayDimensionsContext) Accept 

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

func (*ArrayDimensionsContext) AllINT_LITERAL 

func (s *ArrayDimensionsContext) AllINT_LITERAL() []antlr.TerminalNode

func (*ArrayDimensionsContext) AllLBRACK 

func (s *ArrayDimensionsContext) AllLBRACK() []antlr.TerminalNode

func (*ArrayDimensionsContext) AllRBRACK 

func (s *ArrayDimensionsContext) AllRBRACK() []antlr.TerminalNode

func (*ArrayDimensionsContext) EnterRule 

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

func (*ArrayDimensionsContext) ExitRule 

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

func (*ArrayDimensionsContext) GetParser 

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

func (*ArrayDimensionsContext) GetRuleContext 

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

func (*ArrayDimensionsContext) INT_LITERAL 

func (s *ArrayDimensionsContext) INT_LITERAL(i int) antlr.TerminalNode

func (*ArrayDimensionsContext) IsArrayDimensionsContext 

func (*ArrayDimensionsContext) IsArrayDimensionsContext()

func (*ArrayDimensionsContext) LBRACK 

func (s *ArrayDimensionsContext) LBRACK(i int) antlr.TerminalNode

func (*ArrayDimensionsContext) RBRACK 

func (s *ArrayDimensionsContext) RBRACK(i int) antlr.TerminalNode

func (*ArrayDimensionsContext) ToStringTree 

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

type ArrayLiteralContext 

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

func NewArrayLiteralContext 

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

func NewEmptyArrayLiteralContext 

func NewEmptyArrayLiteralContext() *ArrayLiteralContext

func (*ArrayLiteralContext) Accept 

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

func (*ArrayLiteralContext) AllCOMMA 

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

func (*ArrayLiteralContext) AllExpression 

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

func (*ArrayLiteralContext) COMMA 

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

func (*ArrayLiteralContext) EnterRule 

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

func (*ArrayLiteralContext) ExitRule 

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

func (*ArrayLiteralContext) Expression 

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

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

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

func (*ArrayLiteralContext) RBRACK 

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

func (*ArrayLiteralContext) ToStringTree 

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

type AssignmentContext 

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

func NewAssignmentContext 

func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext

func NewEmptyAssignmentContext 

func NewEmptyAssignmentContext() *AssignmentContext

func (*AssignmentContext) Accept 

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

func (*AssignmentContext) AllExpression added in v0.1.4 

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

func (*AssignmentContext) AssignmentOperator 

func (s *AssignmentContext) AssignmentOperator() IAssignmentOperatorContext

func (*AssignmentContext) DECREMENT 

func (s *AssignmentContext) DECREMENT() antlr.TerminalNode

func (*AssignmentContext) EnterRule 

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

func (*AssignmentContext) ExitRule 

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

func (*AssignmentContext) Expression 

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

func (*AssignmentContext) GetParser 

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

func (*AssignmentContext) GetRuleContext 

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

func (*AssignmentContext) IDENTIFIER 

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

func (*AssignmentContext) INCREMENT 

func (s *AssignmentContext) INCREMENT() antlr.TerminalNode

func (*AssignmentContext) IsAssignmentContext 

func (*AssignmentContext) IsAssignmentContext()

func (*AssignmentContext) LBRACK added in v0.1.4 

func (s *AssignmentContext) LBRACK() antlr.TerminalNode

func (*AssignmentContext) RBRACK added in v0.1.4 

func (s *AssignmentContext) RBRACK() antlr.TerminalNode

func (*AssignmentContext) ToStringTree 

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

type AssignmentDeclarationContext 

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

func NewAssignmentDeclarationContext 

func NewAssignmentDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentDeclarationContext

func NewEmptyAssignmentDeclarationContext 

func NewEmptyAssignmentDeclarationContext() *AssignmentDeclarationContext

func (*AssignmentDeclarationContext) Accept 

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

func (*AssignmentDeclarationContext) Assignment 

func (s *AssignmentDeclarationContext) Assignment() IAssignmentContext

func (*AssignmentDeclarationContext) EnterRule 

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

func (*AssignmentDeclarationContext) ExitRule 

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

func (*AssignmentDeclarationContext) GetParser 

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

func (*AssignmentDeclarationContext) GetRuleContext 

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

func (*AssignmentDeclarationContext) IsAssignmentDeclarationContext 

func (*AssignmentDeclarationContext) IsAssignmentDeclarationContext()

func (*AssignmentDeclarationContext) SEMI 

func (s *AssignmentDeclarationContext) SEMI() antlr.TerminalNode

func (*AssignmentDeclarationContext) ToStringTree 

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

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

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

func (*AssignmentOperatorContext) Accept 

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

func (*AssignmentOperatorContext) DIV_ASSIGN 

func (s *AssignmentOperatorContext) DIV_ASSIGN() 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) MINUS_ASSIGN 

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

func (*AssignmentOperatorContext) MOD_ASSIGN 

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

func (*AssignmentOperatorContext) MULT_ASSIGN 

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

func (*AssignmentOperatorContext) PLUS_ASSIGN 

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

func (*AssignmentOperatorContext) ToStringTree 

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

type BaseR2D2Listener 

type BaseR2D2Listener struct{}

BaseR2D2Listener is a complete listener for a parse tree produced by R2D2Parser.

func (*BaseR2D2Listener) EnterAdditiveExpression 

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

EnterAdditiveExpression is called when production additiveExpression is entered.

func (*BaseR2D2Listener) EnterArgumentList 

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

EnterArgumentList is called when production argumentList is entered.

func (*BaseR2D2Listener) EnterArrayAccessExpression added in v0.1.1 

func (s *BaseR2D2Listener) EnterArrayAccessExpression(ctx *ArrayAccessExpressionContext)

EnterArrayAccessExpression is called when production arrayAccessExpression is entered.

func (*BaseR2D2Listener) EnterArrayDimensions 

func (s *BaseR2D2Listener) EnterArrayDimensions(ctx *ArrayDimensionsContext)

EnterArrayDimensions is called when production arrayDimensions is entered.

func (*BaseR2D2Listener) EnterArrayLiteral 

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

EnterArrayLiteral is called when production arrayLiteral is entered.

func (*BaseR2D2Listener) EnterAssignment 

func (s *BaseR2D2Listener) EnterAssignment(ctx *AssignmentContext)

EnterAssignment is called when production assignment is entered.

func (*BaseR2D2Listener) EnterAssignmentDeclaration 

func (s *BaseR2D2Listener) EnterAssignmentDeclaration(ctx *AssignmentDeclarationContext)

EnterAssignmentDeclaration is called when production assignmentDeclaration is entered.

func (*BaseR2D2Listener) EnterAssignmentOperator 

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

EnterAssignmentOperator is called when production assignmentOperator is entered.

func (*BaseR2D2Listener) EnterBaseType 

func (s *BaseR2D2Listener) EnterBaseType(ctx *BaseTypeContext)

EnterBaseType is called when production baseType is entered.

func (*BaseR2D2Listener) EnterBlock 

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

EnterBlock is called when production block is entered.

func (*BaseR2D2Listener) EnterBreakStatement 

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

EnterBreakStatement is called when production breakStatement is entered.

func (*BaseR2D2Listener) EnterCicleControl 

func (s *BaseR2D2Listener) EnterCicleControl(ctx *CicleControlContext)

EnterCicleControl is called when production cicleControl is entered.

func (*BaseR2D2Listener) EnterComparisonExpression 

func (s *BaseR2D2Listener) EnterComparisonExpression(ctx *ComparisonExpressionContext)

EnterComparisonExpression is called when production comparisonExpression is entered.

func (*BaseR2D2Listener) EnterContinueStatement 

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

EnterContinueStatement is called when production continueStatement is entered.

func (*BaseR2D2Listener) EnterDeclaration 

func (s *BaseR2D2Listener) EnterDeclaration(ctx *DeclarationContext)

EnterDeclaration is called when production declaration is entered.

func (*BaseR2D2Listener) EnterDefaultCase 

func (s *BaseR2D2Listener) EnterDefaultCase(ctx *DefaultCaseContext)

EnterDefaultCase is called when production defaultCase is entered.

func (*BaseR2D2Listener) EnterEveryRule 

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

EnterEveryRule is called when any rule is entered.

func (*BaseR2D2Listener) EnterExpressionStatement 

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

EnterExpressionStatement is called when production expressionStatement is entered.

func (*BaseR2D2Listener) EnterForStatement 

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

EnterForStatement is called when production forStatement is entered.

func (*BaseR2D2Listener) EnterFunctionCall 

func (s *BaseR2D2Listener) EnterFunctionCall(ctx *FunctionCallContext)

EnterFunctionCall is called when production functionCall is entered.

func (*BaseR2D2Listener) EnterFunctionCallExpression added in v0.1.1 

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

EnterFunctionCallExpression is called when production functionCallExpression is entered.

func (*BaseR2D2Listener) EnterFunctionCallStatement 

func (s *BaseR2D2Listener) EnterFunctionCallStatement(ctx *FunctionCallStatementContext)

EnterFunctionCallStatement is called when production functionCallStatement is entered.

func (*BaseR2D2Listener) EnterFunctionDeclaration 

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

EnterFunctionDeclaration is called when production functionDeclaration is entered.

func (*BaseR2D2Listener) EnterGenericType 

func (s *BaseR2D2Listener) EnterGenericType(ctx *GenericTypeContext)

EnterGenericType is called when production genericType is entered.

func (*BaseR2D2Listener) EnterGlobalDeclaration 

func (s *BaseR2D2Listener) EnterGlobalDeclaration(ctx *GlobalDeclarationContext)

EnterGlobalDeclaration is called when production globalDeclaration is entered.

func (*BaseR2D2Listener) EnterIdentifierExpression added in v0.1.1 

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

EnterIdentifierExpression is called when production identifierExpression is entered.

func (*BaseR2D2Listener) EnterIfStatement 

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

EnterIfStatement is called when production ifStatement is entered.

func (*BaseR2D2Listener) EnterImportDeclaration 

func (s *BaseR2D2Listener) EnterImportDeclaration(ctx *ImportDeclarationContext)

EnterImportDeclaration is called when production importDeclaration is entered.

func (*BaseR2D2Listener) EnterInterfaceDeclaration 

func (s *BaseR2D2Listener) EnterInterfaceDeclaration(ctx *InterfaceDeclarationContext)

EnterInterfaceDeclaration is called when production interfaceDeclaration is entered.

func (*BaseR2D2Listener) EnterJsStatement added in v0.1.1 

func (s *BaseR2D2Listener) EnterJsStatement(ctx *JsStatementContext)

EnterJsStatement is called when production jsStatement is entered.

func (*BaseR2D2Listener) EnterLiteral 

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

EnterLiteral is called when production literal is entered.

func (*BaseR2D2Listener) EnterLiteralExpression added in v0.1.1 

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

EnterLiteralExpression is called when production literalExpression is entered.

func (*BaseR2D2Listener) EnterLogicalExpression 

func (s *BaseR2D2Listener) EnterLogicalExpression(ctx *LogicalExpressionContext)

EnterLogicalExpression is called when production logicalExpression is entered.

func (*BaseR2D2Listener) EnterLoopStatement 

func (s *BaseR2D2Listener) EnterLoopStatement(ctx *LoopStatementContext)

EnterLoopStatement is called when production loopStatement is entered.

func (*BaseR2D2Listener) EnterModuleDeclaration 

func (s *BaseR2D2Listener) EnterModuleDeclaration(ctx *ModuleDeclarationContext)

EnterModuleDeclaration is called when production moduleDeclaration is entered.

func (*BaseR2D2Listener) EnterMultiplicativeExpression 

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

EnterMultiplicativeExpression is called when production multiplicativeExpression is entered.

func (*BaseR2D2Listener) EnterObjectLiteral added in v0.2.2 

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

EnterObjectLiteral is called when production objectLiteral is entered.

func (*BaseR2D2Listener) EnterParameter 

func (s *BaseR2D2Listener) EnterParameter(ctx *ParameterContext)

EnterParameter is called when production parameter is entered.

func (*BaseR2D2Listener) EnterParameterList 

func (s *BaseR2D2Listener) EnterParameterList(ctx *ParameterListContext)

EnterParameterList is called when production parameterList is entered.

func (*BaseR2D2Listener) EnterParenthesisExpression added in v0.1.1 

func (s *BaseR2D2Listener) EnterParenthesisExpression(ctx *ParenthesisExpressionContext)

EnterParenthesisExpression is called when production parenthesisExpression is entered.

func (*BaseR2D2Listener) EnterProgram 

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

EnterProgram is called when production program is entered.

func (*BaseR2D2Listener) EnterReturnStatement 

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

EnterReturnStatement is called when production returnStatement is entered.

func (*BaseR2D2Listener) EnterSimpleFor 

func (s *BaseR2D2Listener) EnterSimpleFor(ctx *SimpleForContext)

EnterSimpleFor is called when production simpleFor is entered.

func (*BaseR2D2Listener) EnterStatement 

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

EnterStatement is called when production statement is entered.

func (*BaseR2D2Listener) EnterSwitchCase 

func (s *BaseR2D2Listener) EnterSwitchCase(ctx *SwitchCaseContext)

EnterSwitchCase is called when production switchCase is entered.

func (*BaseR2D2Listener) EnterSwitchStatement 

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

EnterSwitchStatement is called when production switchStatement is entered.

func (*BaseR2D2Listener) EnterTypeDeclaration 

func (s *BaseR2D2Listener) EnterTypeDeclaration(ctx *TypeDeclarationContext)

EnterTypeDeclaration is called when production typeDeclaration is entered.

func (*BaseR2D2Listener) EnterTypeExpression 

func (s *BaseR2D2Listener) EnterTypeExpression(ctx *TypeExpressionContext)

EnterTypeExpression is called when production typeExpression is entered.

func (*BaseR2D2Listener) EnterUnaryExpression 

func (s *BaseR2D2Listener) EnterUnaryExpression(ctx *UnaryExpressionContext)

EnterUnaryExpression is called when production unaryExpression is entered.

func (*BaseR2D2Listener) EnterVariableDeclaration 

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

EnterVariableDeclaration is called when production variableDeclaration is entered.

func (*BaseR2D2Listener) EnterWhileStatement 

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

EnterWhileStatement is called when production whileStatement is entered.

func (*BaseR2D2Listener) ExitAdditiveExpression 

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

ExitAdditiveExpression is called when production additiveExpression is exited.

func (*BaseR2D2Listener) ExitArgumentList 

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

ExitArgumentList is called when production argumentList is exited.

func (*BaseR2D2Listener) ExitArrayAccessExpression added in v0.1.1 

func (s *BaseR2D2Listener) ExitArrayAccessExpression(ctx *ArrayAccessExpressionContext)

ExitArrayAccessExpression is called when production arrayAccessExpression is exited.

func (*BaseR2D2Listener) ExitArrayDimensions 

func (s *BaseR2D2Listener) ExitArrayDimensions(ctx *ArrayDimensionsContext)

ExitArrayDimensions is called when production arrayDimensions is exited.

func (*BaseR2D2Listener) ExitArrayLiteral 

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

ExitArrayLiteral is called when production arrayLiteral is exited.

func (*BaseR2D2Listener) ExitAssignment 

func (s *BaseR2D2Listener) ExitAssignment(ctx *AssignmentContext)

ExitAssignment is called when production assignment is exited.

func (*BaseR2D2Listener) ExitAssignmentDeclaration 

func (s *BaseR2D2Listener) ExitAssignmentDeclaration(ctx *AssignmentDeclarationContext)

ExitAssignmentDeclaration is called when production assignmentDeclaration is exited.

func (*BaseR2D2Listener) ExitAssignmentOperator 

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

ExitAssignmentOperator is called when production assignmentOperator is exited.

func (*BaseR2D2Listener) ExitBaseType 

func (s *BaseR2D2Listener) ExitBaseType(ctx *BaseTypeContext)

ExitBaseType is called when production baseType is exited.

func (*BaseR2D2Listener) ExitBlock 

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

ExitBlock is called when production block is exited.

func (*BaseR2D2Listener) ExitBreakStatement 

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

ExitBreakStatement is called when production breakStatement is exited.

func (*BaseR2D2Listener) ExitCicleControl 

func (s *BaseR2D2Listener) ExitCicleControl(ctx *CicleControlContext)

ExitCicleControl is called when production cicleControl is exited.

func (*BaseR2D2Listener) ExitComparisonExpression 

func (s *BaseR2D2Listener) ExitComparisonExpression(ctx *ComparisonExpressionContext)

ExitComparisonExpression is called when production comparisonExpression is exited.

func (*BaseR2D2Listener) ExitContinueStatement 

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

ExitContinueStatement is called when production continueStatement is exited.

func (*BaseR2D2Listener) ExitDeclaration 

func (s *BaseR2D2Listener) ExitDeclaration(ctx *DeclarationContext)

ExitDeclaration is called when production declaration is exited.

func (*BaseR2D2Listener) ExitDefaultCase 

func (s *BaseR2D2Listener) ExitDefaultCase(ctx *DefaultCaseContext)

ExitDefaultCase is called when production defaultCase is exited.

func (*BaseR2D2Listener) ExitEveryRule 

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

ExitEveryRule is called when any rule is exited.

func (*BaseR2D2Listener) ExitExpressionStatement 

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

ExitExpressionStatement is called when production expressionStatement is exited.

func (*BaseR2D2Listener) ExitForStatement 

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

ExitForStatement is called when production forStatement is exited.

func (*BaseR2D2Listener) ExitFunctionCall 

func (s *BaseR2D2Listener) ExitFunctionCall(ctx *FunctionCallContext)

ExitFunctionCall is called when production functionCall is exited.

func (*BaseR2D2Listener) ExitFunctionCallExpression added in v0.1.1 

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

ExitFunctionCallExpression is called when production functionCallExpression is exited.

func (*BaseR2D2Listener) ExitFunctionCallStatement 

func (s *BaseR2D2Listener) ExitFunctionCallStatement(ctx *FunctionCallStatementContext)

ExitFunctionCallStatement is called when production functionCallStatement is exited.

func (*BaseR2D2Listener) ExitFunctionDeclaration 

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

ExitFunctionDeclaration is called when production functionDeclaration is exited.

func (*BaseR2D2Listener) ExitGenericType 

func (s *BaseR2D2Listener) ExitGenericType(ctx *GenericTypeContext)

ExitGenericType is called when production genericType is exited.

func (*BaseR2D2Listener) ExitGlobalDeclaration 

func (s *BaseR2D2Listener) ExitGlobalDeclaration(ctx *GlobalDeclarationContext)

ExitGlobalDeclaration is called when production globalDeclaration is exited.

func (*BaseR2D2Listener) ExitIdentifierExpression added in v0.1.1 

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

ExitIdentifierExpression is called when production identifierExpression is exited.

func (*BaseR2D2Listener) ExitIfStatement 

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

ExitIfStatement is called when production ifStatement is exited.

func (*BaseR2D2Listener) ExitImportDeclaration 

func (s *BaseR2D2Listener) ExitImportDeclaration(ctx *ImportDeclarationContext)

ExitImportDeclaration is called when production importDeclaration is exited.

func (*BaseR2D2Listener) ExitInterfaceDeclaration 

func (s *BaseR2D2Listener) ExitInterfaceDeclaration(ctx *InterfaceDeclarationContext)

ExitInterfaceDeclaration is called when production interfaceDeclaration is exited.

func (*BaseR2D2Listener) ExitJsStatement added in v0.1.1 

func (s *BaseR2D2Listener) ExitJsStatement(ctx *JsStatementContext)

ExitJsStatement is called when production jsStatement is exited.

func (*BaseR2D2Listener) ExitLiteral 

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

ExitLiteral is called when production literal is exited.

func (*BaseR2D2Listener) ExitLiteralExpression added in v0.1.1 

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

ExitLiteralExpression is called when production literalExpression is exited.

func (*BaseR2D2Listener) ExitLogicalExpression 

func (s *BaseR2D2Listener) ExitLogicalExpression(ctx *LogicalExpressionContext)

ExitLogicalExpression is called when production logicalExpression is exited.

func (*BaseR2D2Listener) ExitLoopStatement 

func (s *BaseR2D2Listener) ExitLoopStatement(ctx *LoopStatementContext)

ExitLoopStatement is called when production loopStatement is exited.

func (*BaseR2D2Listener) ExitModuleDeclaration 

func (s *BaseR2D2Listener) ExitModuleDeclaration(ctx *ModuleDeclarationContext)

ExitModuleDeclaration is called when production moduleDeclaration is exited.

func (*BaseR2D2Listener) ExitMultiplicativeExpression 

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

ExitMultiplicativeExpression is called when production multiplicativeExpression is exited.

func (*BaseR2D2Listener) ExitObjectLiteral added in v0.2.2 

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

ExitObjectLiteral is called when production objectLiteral is exited.

func (*BaseR2D2Listener) ExitParameter 

func (s *BaseR2D2Listener) ExitParameter(ctx *ParameterContext)

ExitParameter is called when production parameter is exited.

func (*BaseR2D2Listener) ExitParameterList 

func (s *BaseR2D2Listener) ExitParameterList(ctx *ParameterListContext)

ExitParameterList is called when production parameterList is exited.

func (*BaseR2D2Listener) ExitParenthesisExpression added in v0.1.1 

func (s *BaseR2D2Listener) ExitParenthesisExpression(ctx *ParenthesisExpressionContext)

ExitParenthesisExpression is called when production parenthesisExpression is exited.

func (*BaseR2D2Listener) ExitProgram 

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

ExitProgram is called when production program is exited.

func (*BaseR2D2Listener) ExitReturnStatement 

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

ExitReturnStatement is called when production returnStatement is exited.

func (*BaseR2D2Listener) ExitSimpleFor 

func (s *BaseR2D2Listener) ExitSimpleFor(ctx *SimpleForContext)

ExitSimpleFor is called when production simpleFor is exited.

func (*BaseR2D2Listener) ExitStatement 

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

ExitStatement is called when production statement is exited.

func (*BaseR2D2Listener) ExitSwitchCase 

func (s *BaseR2D2Listener) ExitSwitchCase(ctx *SwitchCaseContext)

ExitSwitchCase is called when production switchCase is exited.

func (*BaseR2D2Listener) ExitSwitchStatement 

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

ExitSwitchStatement is called when production switchStatement is exited.

func (*BaseR2D2Listener) ExitTypeDeclaration 

func (s *BaseR2D2Listener) ExitTypeDeclaration(ctx *TypeDeclarationContext)

ExitTypeDeclaration is called when production typeDeclaration is exited.

func (*BaseR2D2Listener) ExitTypeExpression 

func (s *BaseR2D2Listener) ExitTypeExpression(ctx *TypeExpressionContext)

ExitTypeExpression is called when production typeExpression is exited.

func (*BaseR2D2Listener) ExitUnaryExpression 

func (s *BaseR2D2Listener) ExitUnaryExpression(ctx *UnaryExpressionContext)

ExitUnaryExpression is called when production unaryExpression is exited.

func (*BaseR2D2Listener) ExitVariableDeclaration 

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

ExitVariableDeclaration is called when production variableDeclaration is exited.

func (*BaseR2D2Listener) ExitWhileStatement 

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

ExitWhileStatement is called when production whileStatement is exited.

func (*BaseR2D2Listener) VisitErrorNode 

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

VisitErrorNode is called when an error node is visited.

func (*BaseR2D2Listener) VisitTerminal 

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

VisitTerminal is called when a terminal node is visited.

type BaseR2D2Visitor 

type BaseR2D2Visitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseR2D2Visitor) VisitAdditiveExpression 

func (v *BaseR2D2Visitor) VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitArgumentList 

func (v *BaseR2D2Visitor) VisitArgumentList(ctx *ArgumentListContext) interface{}

func (*BaseR2D2Visitor) VisitArrayAccessExpression added in v0.1.1 

func (v *BaseR2D2Visitor) VisitArrayAccessExpression(ctx *ArrayAccessExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitArrayDimensions 

func (v *BaseR2D2Visitor) VisitArrayDimensions(ctx *ArrayDimensionsContext) interface{}

func (*BaseR2D2Visitor) VisitArrayLiteral 

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

func (*BaseR2D2Visitor) VisitAssignment 

func (v *BaseR2D2Visitor) VisitAssignment(ctx *AssignmentContext) interface{}

func (*BaseR2D2Visitor) VisitAssignmentDeclaration 

func (v *BaseR2D2Visitor) VisitAssignmentDeclaration(ctx *AssignmentDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitAssignmentOperator 

func (v *BaseR2D2Visitor) VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}

func (*BaseR2D2Visitor) VisitBaseType 

func (v *BaseR2D2Visitor) VisitBaseType(ctx *BaseTypeContext) interface{}

func (*BaseR2D2Visitor) VisitBlock 

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

func (*BaseR2D2Visitor) VisitBreakStatement 

func (v *BaseR2D2Visitor) VisitBreakStatement(ctx *BreakStatementContext) interface{}

func (*BaseR2D2Visitor) VisitCicleControl 

func (v *BaseR2D2Visitor) VisitCicleControl(ctx *CicleControlContext) interface{}

func (*BaseR2D2Visitor) VisitComparisonExpression 

func (v *BaseR2D2Visitor) VisitComparisonExpression(ctx *ComparisonExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitContinueStatement 

func (v *BaseR2D2Visitor) VisitContinueStatement(ctx *ContinueStatementContext) interface{}

func (*BaseR2D2Visitor) VisitDeclaration 

func (v *BaseR2D2Visitor) VisitDeclaration(ctx *DeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitDefaultCase 

func (v *BaseR2D2Visitor) VisitDefaultCase(ctx *DefaultCaseContext) interface{}

func (*BaseR2D2Visitor) VisitExpressionStatement 

func (v *BaseR2D2Visitor) VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

func (*BaseR2D2Visitor) VisitForStatement 

func (v *BaseR2D2Visitor) VisitForStatement(ctx *ForStatementContext) interface{}

func (*BaseR2D2Visitor) VisitFunctionCall 

func (v *BaseR2D2Visitor) VisitFunctionCall(ctx *FunctionCallContext) interface{}

func (*BaseR2D2Visitor) VisitFunctionCallExpression added in v0.1.1 

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

func (*BaseR2D2Visitor) VisitFunctionCallStatement 

func (v *BaseR2D2Visitor) VisitFunctionCallStatement(ctx *FunctionCallStatementContext) interface{}

func (*BaseR2D2Visitor) VisitFunctionDeclaration 

func (v *BaseR2D2Visitor) VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitGenericType 

func (v *BaseR2D2Visitor) VisitGenericType(ctx *GenericTypeContext) interface{}

func (*BaseR2D2Visitor) VisitGlobalDeclaration 

func (v *BaseR2D2Visitor) VisitGlobalDeclaration(ctx *GlobalDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitIdentifierExpression added in v0.1.1 

func (v *BaseR2D2Visitor) VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitIfStatement 

func (v *BaseR2D2Visitor) VisitIfStatement(ctx *IfStatementContext) interface{}

func (*BaseR2D2Visitor) VisitImportDeclaration 

func (v *BaseR2D2Visitor) VisitImportDeclaration(ctx *ImportDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitInterfaceDeclaration 

func (v *BaseR2D2Visitor) VisitInterfaceDeclaration(ctx *InterfaceDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitJsStatement added in v0.1.1 

func (v *BaseR2D2Visitor) VisitJsStatement(ctx *JsStatementContext) interface{}

func (*BaseR2D2Visitor) VisitLiteral 

func (v *BaseR2D2Visitor) VisitLiteral(ctx *LiteralContext) interface{}

func (*BaseR2D2Visitor) VisitLiteralExpression added in v0.1.1 

func (v *BaseR2D2Visitor) VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitLogicalExpression 

func (v *BaseR2D2Visitor) VisitLogicalExpression(ctx *LogicalExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitLoopStatement 

func (v *BaseR2D2Visitor) VisitLoopStatement(ctx *LoopStatementContext) interface{}

func (*BaseR2D2Visitor) VisitModuleDeclaration 

func (v *BaseR2D2Visitor) VisitModuleDeclaration(ctx *ModuleDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitMultiplicativeExpression 

func (v *BaseR2D2Visitor) VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitObjectLiteral added in v0.2.2 

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

func (*BaseR2D2Visitor) VisitParameter 

func (v *BaseR2D2Visitor) VisitParameter(ctx *ParameterContext) interface{}

func (*BaseR2D2Visitor) VisitParameterList 

func (v *BaseR2D2Visitor) VisitParameterList(ctx *ParameterListContext) interface{}

func (*BaseR2D2Visitor) VisitParenthesisExpression added in v0.1.1 

func (v *BaseR2D2Visitor) VisitParenthesisExpression(ctx *ParenthesisExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitProgram 

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

func (*BaseR2D2Visitor) VisitReturnStatement 

func (v *BaseR2D2Visitor) VisitReturnStatement(ctx *ReturnStatementContext) interface{}

func (*BaseR2D2Visitor) VisitSimpleFor 

func (v *BaseR2D2Visitor) VisitSimpleFor(ctx *SimpleForContext) interface{}

func (*BaseR2D2Visitor) VisitStatement 

func (v *BaseR2D2Visitor) VisitStatement(ctx *StatementContext) interface{}

func (*BaseR2D2Visitor) VisitSwitchCase 

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

func (*BaseR2D2Visitor) VisitSwitchStatement 

func (v *BaseR2D2Visitor) VisitSwitchStatement(ctx *SwitchStatementContext) interface{}

func (*BaseR2D2Visitor) VisitTypeDeclaration 

func (v *BaseR2D2Visitor) VisitTypeDeclaration(ctx *TypeDeclarationContext) interface{}

func (*BaseR2D2Visitor) VisitTypeExpression 

func (v *BaseR2D2Visitor) VisitTypeExpression(ctx *TypeExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitUnaryExpression 

func (v *BaseR2D2Visitor) VisitUnaryExpression(ctx *UnaryExpressionContext) interface{}

func (*BaseR2D2Visitor) VisitVariableDeclaration 

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

func (*BaseR2D2Visitor) VisitWhileStatement 

func (v *BaseR2D2Visitor) VisitWhileStatement(ctx *WhileStatementContext) interface{}

type BaseTypeContext 

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

func NewBaseTypeContext 

func NewBaseTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BaseTypeContext

func NewEmptyBaseTypeContext 

func NewEmptyBaseTypeContext() *BaseTypeContext

func (*BaseTypeContext) Accept 

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

func (*BaseTypeContext) EnterRule 

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

func (*BaseTypeContext) ExitRule 

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

func (*BaseTypeContext) GenericType 

func (s *BaseTypeContext) GenericType() IGenericTypeContext

func (*BaseTypeContext) GetParser 

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

func (*BaseTypeContext) GetRuleContext 

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

func (*BaseTypeContext) IDENTIFIER 

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

func (*BaseTypeContext) IsBaseTypeContext 

func (*BaseTypeContext) IsBaseTypeContext()

func (*BaseTypeContext) TYPE 

func (s *BaseTypeContext) TYPE() antlr.TerminalNode

func (*BaseTypeContext) ToStringTree 

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

type BlockContext 

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

func NewBlockContext 

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

func NewEmptyBlockContext 

func NewEmptyBlockContext() *BlockContext

func (*BlockContext) Accept 

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

func (*BlockContext) AllStatement 

func (s *BlockContext) AllStatement() []IStatementContext

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

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

func (*BlockContext) RBRACE 

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

func (*BlockContext) Statement 

func (s *BlockContext) Statement(i int) IStatementContext

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

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

func (*BreakStatementContext) BREAK 

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

func (*BreakStatementContext) EnterRule 

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

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

func (*BreakStatementContext) IsBreakStatementContext()

func (*BreakStatementContext) SEMI 

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

func (*BreakStatementContext) ToStringTree 

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

type CicleControlContext 

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

func NewCicleControlContext 

func NewCicleControlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CicleControlContext

func NewEmptyCicleControlContext 

func NewEmptyCicleControlContext() *CicleControlContext

func (*CicleControlContext) Accept 

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

func (*CicleControlContext) BreakStatement 

func (s *CicleControlContext) BreakStatement() IBreakStatementContext

func (*CicleControlContext) ContinueStatement 

func (s *CicleControlContext) ContinueStatement() IContinueStatementContext

func (*CicleControlContext) EnterRule 

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

func (*CicleControlContext) ExitRule 

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

func (*CicleControlContext) GetParser 

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

func (*CicleControlContext) GetRuleContext 

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

func (*CicleControlContext) IsCicleControlContext 

func (*CicleControlContext) IsCicleControlContext()

func (*CicleControlContext) ToStringTree 

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

type ComparisonExpressionContext 

type ComparisonExpressionContext struct {
	ExpressionContext
}

func NewComparisonExpressionContext 

func NewComparisonExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComparisonExpressionContext

func (*ComparisonExpressionContext) Accept 

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

func (*ComparisonExpressionContext) AllExpression added in v0.1.1 

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

func (*ComparisonExpressionContext) EQ 

func (s *ComparisonExpressionContext) EQ() antlr.TerminalNode

func (*ComparisonExpressionContext) EnterRule 

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

func (*ComparisonExpressionContext) ExitRule 

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

func (*ComparisonExpressionContext) Expression added in v0.1.1 

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

func (*ComparisonExpressionContext) GEQ 

func (s *ComparisonExpressionContext) GEQ() antlr.TerminalNode

func (*ComparisonExpressionContext) GT 

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

func (*ComparisonExpressionContext) GetRuleContext 

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

func (*ComparisonExpressionContext) LEQ 

func (s *ComparisonExpressionContext) LEQ() antlr.TerminalNode

func (*ComparisonExpressionContext) LT 

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

func (*ComparisonExpressionContext) NEQ 

func (s *ComparisonExpressionContext) NEQ() antlr.TerminalNode

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

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

func (*ContinueStatementContext) CONTINUE 

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

func (*ContinueStatementContext) EnterRule 

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

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

func (*ContinueStatementContext) IsContinueStatementContext()

func (*ContinueStatementContext) SEMI 

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

func (*ContinueStatementContext) ToStringTree 

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

type DeclarationContext 

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

func NewDeclarationContext 

func NewDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarationContext

func NewEmptyDeclarationContext 

func NewEmptyDeclarationContext() *DeclarationContext

func (*DeclarationContext) Accept 

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

func (*DeclarationContext) EnterRule 

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

func (*DeclarationContext) ExitRule 

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

func (*DeclarationContext) GetParser 

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

func (*DeclarationContext) GetRuleContext 

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

func (*DeclarationContext) GlobalDeclaration 

func (s *DeclarationContext) GlobalDeclaration() IGlobalDeclarationContext

func (*DeclarationContext) IsDeclarationContext 

func (*DeclarationContext) IsDeclarationContext()

func (*DeclarationContext) ModuleDeclaration 

func (s *DeclarationContext) ModuleDeclaration() IModuleDeclarationContext

func (*DeclarationContext) ToStringTree 

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

func (*DeclarationContext) TypeDeclaration added in v0.1.1 

func (s *DeclarationContext) TypeDeclaration() ITypeDeclarationContext

type DefaultCaseContext 

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

func NewDefaultCaseContext 

func NewDefaultCaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultCaseContext

func NewEmptyDefaultCaseContext 

func NewEmptyDefaultCaseContext() *DefaultCaseContext

func (*DefaultCaseContext) ARROW added in v0.1.3 

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

func (*DefaultCaseContext) Accept 

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

func (*DefaultCaseContext) Block 

func (s *DefaultCaseContext) Block() IBlockContext

func (*DefaultCaseContext) DEFAULT 

func (s *DefaultCaseContext) DEFAULT() antlr.TerminalNode

func (*DefaultCaseContext) EnterRule 

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

func (*DefaultCaseContext) ExitRule 

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

func (*DefaultCaseContext) GetParser 

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

func (*DefaultCaseContext) GetRuleContext 

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

func (*DefaultCaseContext) IsDefaultCaseContext 

func (*DefaultCaseContext) IsDefaultCaseContext()

func (*DefaultCaseContext) Statement added in v0.1.3 

func (s *DefaultCaseContext) Statement() IStatementContext

func (*DefaultCaseContext) ToStringTree 

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

type ExpressionContext 

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

func NewEmptyExpressionContext 

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext 

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

func (*ExpressionContext) CopyAll added in v0.1.1 

func (s *ExpressionContext) CopyAll(ctx *ExpressionContext)

func (*ExpressionContext) GetParser 

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

func (*ExpressionContext) GetRuleContext 

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

func (*ExpressionContext) IsExpressionContext 

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) ToStringTree 

func (s *ExpressionContext) 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) Accept 

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

func (*ExpressionStatementContext) EnterRule 

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

func (*ExpressionStatementContext) ExitRule 

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

func (*ExpressionStatementContext) Expression 

func (s *ExpressionStatementContext) Expression() IExpressionContext

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

func (s *ExpressionStatementContext) SEMI() antlr.TerminalNode

func (*ExpressionStatementContext) ToStringTree 

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

type ForStatementContext 

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

func NewEmptyForStatementContext 

func NewEmptyForStatementContext() *ForStatementContext

func NewForStatementContext 

func NewForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStatementContext

func (*ForStatementContext) Accept 

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

func (*ForStatementContext) Block 

func (s *ForStatementContext) Block() IBlockContext

func (*ForStatementContext) EnterRule 

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

func (*ForStatementContext) ExitRule 

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

func (*ForStatementContext) FOR 

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

func (*ForStatementContext) GetParser 

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

func (*ForStatementContext) GetRuleContext 

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

func (*ForStatementContext) IsForStatementContext 

func (*ForStatementContext) IsForStatementContext()

func (*ForStatementContext) LPAREN 

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

func (*ForStatementContext) RPAREN 

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

func (*ForStatementContext) SimpleFor 

func (s *ForStatementContext) SimpleFor() ISimpleForContext

func (*ForStatementContext) ToStringTree 

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

type FunctionCallContext 

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

func NewEmptyFunctionCallContext 

func NewEmptyFunctionCallContext() *FunctionCallContext

func NewFunctionCallContext 

func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext

func (*FunctionCallContext) Accept 

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

func (*FunctionCallContext) AllDOT 

func (s *FunctionCallContext) AllDOT() []antlr.TerminalNode

func (*FunctionCallContext) AllIDENTIFIER 

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

func (*FunctionCallContext) ArgumentList 

func (s *FunctionCallContext) ArgumentList() IArgumentListContext

func (*FunctionCallContext) DOT 

func (s *FunctionCallContext) DOT(i int) antlr.TerminalNode

func (*FunctionCallContext) EnterRule 

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

func (*FunctionCallContext) ExitRule 

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

func (*FunctionCallContext) GetParser 

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

func (*FunctionCallContext) GetRuleContext 

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

func (*FunctionCallContext) IDENTIFIER 

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

func (*FunctionCallContext) IsFunctionCallContext 

func (*FunctionCallContext) IsFunctionCallContext()

func (*FunctionCallContext) LPAREN 

func (s *FunctionCallContext) LPAREN() antlr.TerminalNode

func (*FunctionCallContext) RPAREN 

func (s *FunctionCallContext) RPAREN() antlr.TerminalNode

func (*FunctionCallContext) ToStringTree 

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

type FunctionCallExpressionContext added in v0.1.1 

type FunctionCallExpressionContext struct {
	ExpressionContext
}

func NewFunctionCallExpressionContext added in v0.1.1 

func NewFunctionCallExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionCallExpressionContext

func (*FunctionCallExpressionContext) Accept added in v0.1.1 

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

func (*FunctionCallExpressionContext) EnterRule added in v0.1.1 

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

func (*FunctionCallExpressionContext) ExitRule added in v0.1.1 

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

func (*FunctionCallExpressionContext) FunctionCall added in v0.1.1 

func (s *FunctionCallExpressionContext) FunctionCall() IFunctionCallContext

func (*FunctionCallExpressionContext) GetRuleContext added in v0.1.1 

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

type FunctionCallStatementContext 

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

func NewEmptyFunctionCallStatementContext 

func NewEmptyFunctionCallStatementContext() *FunctionCallStatementContext

func NewFunctionCallStatementContext 

func NewFunctionCallStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallStatementContext

func (*FunctionCallStatementContext) Accept 

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

func (*FunctionCallStatementContext) EnterRule 

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

func (*FunctionCallStatementContext) ExitRule 

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

func (*FunctionCallStatementContext) FunctionCall 

func (s *FunctionCallStatementContext) FunctionCall() IFunctionCallContext

func (*FunctionCallStatementContext) GetParser 

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

func (*FunctionCallStatementContext) GetRuleContext 

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

func (*FunctionCallStatementContext) IsFunctionCallStatementContext 

func (*FunctionCallStatementContext) IsFunctionCallStatementContext()

func (*FunctionCallStatementContext) SEMI 

func (s *FunctionCallStatementContext) SEMI() antlr.TerminalNode

func (*FunctionCallStatementContext) ToStringTree 

func (s *FunctionCallStatementContext) 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) Accept 

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

func (*FunctionDeclarationContext) Block 

func (s *FunctionDeclarationContext) Block() IBlockContext

func (*FunctionDeclarationContext) EXPORT 

func (s *FunctionDeclarationContext) EXPORT() antlr.TerminalNode

func (*FunctionDeclarationContext) EnterRule 

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

func (*FunctionDeclarationContext) ExitRule 

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

func (*FunctionDeclarationContext) FN 

func (s *FunctionDeclarationContext) FN() antlr.TerminalNode

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

func (s *FunctionDeclarationContext) LPAREN() antlr.TerminalNode

func (*FunctionDeclarationContext) PSEUDO 

func (s *FunctionDeclarationContext) PSEUDO() antlr.TerminalNode

func (*FunctionDeclarationContext) ParameterList 

func (s *FunctionDeclarationContext) ParameterList() IParameterListContext

func (*FunctionDeclarationContext) RPAREN 

func (s *FunctionDeclarationContext) RPAREN() antlr.TerminalNode

func (*FunctionDeclarationContext) SEMI 

func (s *FunctionDeclarationContext) SEMI() antlr.TerminalNode

func (*FunctionDeclarationContext) ToStringTree 

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

func (*FunctionDeclarationContext) TypeExpression 

func (s *FunctionDeclarationContext) TypeExpression() ITypeExpressionContext

type GenericTypeContext 

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

func NewEmptyGenericTypeContext 

func NewEmptyGenericTypeContext() *GenericTypeContext

func NewGenericTypeContext 

func NewGenericTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericTypeContext

func (*GenericTypeContext) Accept 

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

func (*GenericTypeContext) AllCOMMA 

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

func (*GenericTypeContext) AllTypeExpression 

func (s *GenericTypeContext) AllTypeExpression() []ITypeExpressionContext

func (*GenericTypeContext) COMMA 

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

func (*GenericTypeContext) EnterRule 

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

func (*GenericTypeContext) ExitRule 

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

func (*GenericTypeContext) GT 

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

func (*GenericTypeContext) GetParser 

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

func (*GenericTypeContext) GetRuleContext 

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

func (*GenericTypeContext) IDENTIFIER 

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

func (*GenericTypeContext) IsGenericTypeContext 

func (*GenericTypeContext) IsGenericTypeContext()

func (*GenericTypeContext) LT 

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

func (*GenericTypeContext) ToStringTree 

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

func (*GenericTypeContext) TypeExpression 

func (s *GenericTypeContext) TypeExpression(i int) ITypeExpressionContext

type GlobalDeclarationContext 

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

func NewEmptyGlobalDeclarationContext 

func NewEmptyGlobalDeclarationContext() *GlobalDeclarationContext

func NewGlobalDeclarationContext 

func NewGlobalDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GlobalDeclarationContext

func (*GlobalDeclarationContext) ASSIGN 

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

func (*GlobalDeclarationContext) Accept 

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

func (*GlobalDeclarationContext) CONST 

func (s *GlobalDeclarationContext) CONST() antlr.TerminalNode

func (*GlobalDeclarationContext) EnterRule 

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

func (*GlobalDeclarationContext) ExitRule 

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

func (*GlobalDeclarationContext) Expression 

func (s *GlobalDeclarationContext) Expression() IExpressionContext

func (*GlobalDeclarationContext) GetParser 

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

func (*GlobalDeclarationContext) GetRuleContext 

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

func (*GlobalDeclarationContext) IDENTIFIER 

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

func (*GlobalDeclarationContext) IsGlobalDeclarationContext 

func (*GlobalDeclarationContext) IsGlobalDeclarationContext()

func (*GlobalDeclarationContext) SEMI 

func (s *GlobalDeclarationContext) SEMI() antlr.TerminalNode

func (*GlobalDeclarationContext) ToStringTree 

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

func (*GlobalDeclarationContext) TypeExpression 

func (s *GlobalDeclarationContext) TypeExpression() ITypeExpressionContext

type IArgumentListContext 

type IArgumentListContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

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

IArgumentListContext is an interface to support dynamic dispatch.

type IArrayDimensionsContext 

type IArrayDimensionsContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllLBRACK() []antlr.TerminalNode
	LBRACK(i int) antlr.TerminalNode
	AllRBRACK() []antlr.TerminalNode
	RBRACK(i int) antlr.TerminalNode
	AllINT_LITERAL() []antlr.TerminalNode
	INT_LITERAL(i int) antlr.TerminalNode

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

IArrayDimensionsContext is an interface to support dynamic dispatch.

type IArrayLiteralContext 

type IArrayLiteralContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	LBRACK() antlr.TerminalNode
	RBRACK() antlr.TerminalNode
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

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

IArrayLiteralContext is an interface to support dynamic dispatch.

type IAssignmentContext 

type IAssignmentContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	AssignmentOperator() IAssignmentOperatorContext
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	INCREMENT() antlr.TerminalNode
	DECREMENT() antlr.TerminalNode
	LBRACK() antlr.TerminalNode
	RBRACK() antlr.TerminalNode

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

IAssignmentContext is an interface to support dynamic dispatch.

type IAssignmentDeclarationContext 

type IAssignmentDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	Assignment() IAssignmentContext
	SEMI() antlr.TerminalNode

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

IAssignmentDeclarationContext is an interface to support dynamic dispatch.

type IAssignmentOperatorContext 

type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ASSIGN() antlr.TerminalNode
	PLUS_ASSIGN() antlr.TerminalNode
	MINUS_ASSIGN() antlr.TerminalNode
	MULT_ASSIGN() antlr.TerminalNode
	DIV_ASSIGN() antlr.TerminalNode
	MOD_ASSIGN() antlr.TerminalNode

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

IAssignmentOperatorContext is an interface to support dynamic dispatch.

type IBaseTypeContext 

type IBaseTypeContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	TYPE() antlr.TerminalNode
	GenericType() IGenericTypeContext

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

IBaseTypeContext is an interface to support dynamic dispatch.

type IBlockContext 

type IBlockContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	LBRACE() antlr.TerminalNode
	RBRACE() antlr.TerminalNode
	AllStatement() []IStatementContext
	Statement(i int) IStatementContext

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

	// Getter signatures
	BREAK() antlr.TerminalNode
	SEMI() antlr.TerminalNode

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

IBreakStatementContext is an interface to support dynamic dispatch.

type ICicleControlContext 

type ICicleControlContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	BreakStatement() IBreakStatementContext
	ContinueStatement() IContinueStatementContext

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

ICicleControlContext is an interface to support dynamic dispatch.

type IContinueStatementContext 

type IContinueStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	CONTINUE() antlr.TerminalNode
	SEMI() antlr.TerminalNode

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

IContinueStatementContext is an interface to support dynamic dispatch.

type IDeclarationContext 

type IDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ModuleDeclaration() IModuleDeclarationContext
	GlobalDeclaration() IGlobalDeclarationContext
	TypeDeclaration() ITypeDeclarationContext

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

IDeclarationContext is an interface to support dynamic dispatch.

type IDefaultCaseContext 

type IDefaultCaseContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	DEFAULT() antlr.TerminalNode
	Block() IBlockContext
	ARROW() antlr.TerminalNode
	Statement() IStatementContext

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

IDefaultCaseContext is an interface to support dynamic dispatch.

type IExpressionContext 

type IExpressionContext interface {
	antlr.ParserRuleContext

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

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionStatementContext 

type IExpressionStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	Expression() IExpressionContext
	SEMI() antlr.TerminalNode

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

IExpressionStatementContext is an interface to support dynamic dispatch.

type IForStatementContext 

type IForStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	FOR() antlr.TerminalNode
	SimpleFor() ISimpleForContext
	Block() IBlockContext
	LPAREN() antlr.TerminalNode
	RPAREN() antlr.TerminalNode

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

IForStatementContext is an interface to support dynamic dispatch.

type IFunctionCallContext 

type IFunctionCallContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllIDENTIFIER() []antlr.TerminalNode
	IDENTIFIER(i int) antlr.TerminalNode
	LPAREN() antlr.TerminalNode
	RPAREN() antlr.TerminalNode
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode
	ArgumentList() IArgumentListContext

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

IFunctionCallContext is an interface to support dynamic dispatch.

type IFunctionCallStatementContext 

type IFunctionCallStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	FunctionCall() IFunctionCallContext
	SEMI() antlr.TerminalNode

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

IFunctionCallStatementContext is an interface to support dynamic dispatch.

type IFunctionDeclarationContext 

type IFunctionDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	FN() antlr.TerminalNode
	IDENTIFIER() antlr.TerminalNode
	LPAREN() antlr.TerminalNode
	RPAREN() antlr.TerminalNode
	Block() IBlockContext
	SEMI() antlr.TerminalNode
	EXPORT() antlr.TerminalNode
	PSEUDO() antlr.TerminalNode
	ParameterList() IParameterListContext
	TypeExpression() ITypeExpressionContext

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

IFunctionDeclarationContext is an interface to support dynamic dispatch.

type IGenericTypeContext 

type IGenericTypeContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	LT() antlr.TerminalNode
	AllTypeExpression() []ITypeExpressionContext
	TypeExpression(i int) ITypeExpressionContext
	GT() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

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

IGenericTypeContext is an interface to support dynamic dispatch.

type IGlobalDeclarationContext 

type IGlobalDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	CONST() antlr.TerminalNode
	IDENTIFIER() antlr.TerminalNode
	TypeExpression() ITypeExpressionContext
	ASSIGN() antlr.TerminalNode
	Expression() IExpressionContext
	SEMI() antlr.TerminalNode

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

IGlobalDeclarationContext is an interface to support dynamic dispatch.

type IIfStatementContext 

type IIfStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllIF() []antlr.TerminalNode
	IF(i int) antlr.TerminalNode
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	AllBlock() []IBlockContext
	Block(i int) IBlockContext
	AllARROW() []antlr.TerminalNode
	ARROW(i int) antlr.TerminalNode
	AllStatement() []IStatementContext
	Statement(i int) IStatementContext
	AllLPAREN() []antlr.TerminalNode
	LPAREN(i int) antlr.TerminalNode
	AllRPAREN() []antlr.TerminalNode
	RPAREN(i int) antlr.TerminalNode
	AllELSE() []antlr.TerminalNode
	ELSE(i int) antlr.TerminalNode

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

IIfStatementContext is an interface to support dynamic dispatch.

type IImportDeclarationContext 

type IImportDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	USE() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode
	SEMI() antlr.TerminalNode

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

IImportDeclarationContext is an interface to support dynamic dispatch.

type IInterfaceDeclarationContext 

type IInterfaceDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	INTERFACE() antlr.TerminalNode
	AllIDENTIFIER() []antlr.TerminalNode
	IDENTIFIER(i int) antlr.TerminalNode
	LBRACE() antlr.TerminalNode
	RBRACE() antlr.TerminalNode
	IMPLEMENTS() antlr.TerminalNode
	AllFunctionDeclaration() []IFunctionDeclarationContext
	FunctionDeclaration(i int) IFunctionDeclarationContext
	AllVariableDeclaration() []IVariableDeclarationContext
	VariableDeclaration(i int) IVariableDeclarationContext

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

IInterfaceDeclarationContext is an interface to support dynamic dispatch.

type IJsStatementContext added in v0.1.1 

type IJsStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AT() antlr.TerminalNode
	JS() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode
	SEMI() antlr.TerminalNode

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

IJsStatementContext is an interface to support dynamic dispatch.

type ILiteralContext 

type ILiteralContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ObjectLiteral() IObjectLiteralContext
	ArrayLiteral() IArrayLiteralContext
	INT_LITERAL() antlr.TerminalNode
	FLOAT_LITERAL() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode
	BOOL_LITERAL() antlr.TerminalNode
	NULL_LITERAL() antlr.TerminalNode

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

ILiteralContext is an interface to support dynamic dispatch.

type ILoopStatementContext 

type ILoopStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	LOOP() antlr.TerminalNode
	Block() IBlockContext

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

ILoopStatementContext is an interface to support dynamic dispatch.

type IModuleDeclarationContext 

type IModuleDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	MODULE() antlr.TerminalNode
	AllIDENTIFIER() []antlr.TerminalNode
	IDENTIFIER(i int) antlr.TerminalNode
	LBRACE() antlr.TerminalNode
	RBRACE() antlr.TerminalNode
	IMPLEMENTS() antlr.TerminalNode
	AllFunctionDeclaration() []IFunctionDeclarationContext
	FunctionDeclaration(i int) IFunctionDeclarationContext
	AllTypeDeclaration() []ITypeDeclarationContext
	TypeDeclaration(i int) ITypeDeclarationContext
	AllVariableDeclaration() []IVariableDeclarationContext
	VariableDeclaration(i int) IVariableDeclarationContext

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

IModuleDeclarationContext is an interface to support dynamic dispatch.

type IObjectLiteralContext added in v0.2.2 

type IObjectLiteralContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	LBRACK() antlr.TerminalNode
	RBRACK() antlr.TerminalNode
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	AllARROW() []antlr.TerminalNode
	ARROW(i int) antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

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

IObjectLiteralContext is an interface to support dynamic dispatch.

type IParameterContext 

type IParameterContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	TypeExpression() ITypeExpressionContext

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

IParameterContext is an interface to support dynamic dispatch.

type IParameterListContext 

type IParameterListContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllParameter() []IParameterContext
	Parameter(i int) IParameterContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

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

IParameterListContext is an interface to support dynamic dispatch.

type IProgramContext 

type IProgramContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	EOF() antlr.TerminalNode
	AllImportDeclaration() []IImportDeclarationContext
	ImportDeclaration(i int) IImportDeclarationContext
	AllInterfaceDeclaration() []IInterfaceDeclarationContext
	InterfaceDeclaration(i int) IInterfaceDeclarationContext
	AllDeclaration() []IDeclarationContext
	Declaration(i int) IDeclarationContext

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

IProgramContext is an interface to support dynamic dispatch.

type IReturnStatementContext 

type IReturnStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	RETURN() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	Expression() IExpressionContext

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

IReturnStatementContext is an interface to support dynamic dispatch.

type ISimpleForContext 

type ISimpleForContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	VariableDeclaration() IVariableDeclarationContext
	AllAssignment() []IAssignmentContext
	Assignment(i int) IAssignmentContext
	AllSEMI() []antlr.TerminalNode
	SEMI(i int) antlr.TerminalNode
	Expression() IExpressionContext

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

ISimpleForContext is an interface to support dynamic dispatch.

type IStatementContext 

type IStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	VariableDeclaration() IVariableDeclarationContext
	FunctionCallStatement() IFunctionCallStatementContext
	ExpressionStatement() IExpressionStatementContext
	IfStatement() IIfStatementContext
	ForStatement() IForStatementContext
	WhileStatement() IWhileStatementContext
	LoopStatement() ILoopStatementContext
	CicleControl() ICicleControlContext
	ReturnStatement() IReturnStatementContext
	SwitchStatement() ISwitchStatementContext
	AssignmentDeclaration() IAssignmentDeclarationContext
	JsStatement() IJsStatementContext

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

IStatementContext is an interface to support dynamic dispatch.

type ISwitchCaseContext 

type ISwitchCaseContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	CASE() antlr.TerminalNode
	Expression() IExpressionContext
	Block() IBlockContext
	ARROW() antlr.TerminalNode
	Statement() IStatementContext

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

ISwitchCaseContext is an interface to support dynamic dispatch.

type ISwitchStatementContext 

type ISwitchStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	SWITCH() antlr.TerminalNode
	Expression() IExpressionContext
	LBRACE() antlr.TerminalNode
	RBRACE() antlr.TerminalNode
	LPAREN() antlr.TerminalNode
	RPAREN() antlr.TerminalNode
	AllSwitchCase() []ISwitchCaseContext
	SwitchCase(i int) ISwitchCaseContext
	DefaultCase() IDefaultCaseContext

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

ISwitchStatementContext is an interface to support dynamic dispatch.

type ITypeDeclarationContext 

type ITypeDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	LBRACE() antlr.TerminalNode
	RBRACE() antlr.TerminalNode
	EXPORT() antlr.TerminalNode
	AllVariableDeclaration() []IVariableDeclarationContext
	VariableDeclaration(i int) IVariableDeclarationContext

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

ITypeDeclarationContext is an interface to support dynamic dispatch.

type ITypeExpressionContext 

type ITypeExpressionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	BaseType() IBaseTypeContext
	ArrayDimensions() IArrayDimensionsContext

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

ITypeExpressionContext is an interface to support dynamic dispatch.

type IVariableDeclarationContext 

type IVariableDeclarationContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	VAR() antlr.TerminalNode
	LET() antlr.TerminalNode
	CONST() antlr.TerminalNode
	EXPORT() antlr.TerminalNode
	TypeExpression() ITypeExpressionContext
	ASSIGN() antlr.TerminalNode
	Expression() IExpressionContext

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

IVariableDeclarationContext is an interface to support dynamic dispatch.

type IWhileStatementContext 

type IWhileStatementContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	WHILE() antlr.TerminalNode
	Expression() IExpressionContext
	Block() IBlockContext
	LPAREN() antlr.TerminalNode
	RPAREN() antlr.TerminalNode

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

IWhileStatementContext is an interface to support dynamic dispatch.

type IdentifierExpressionContext added in v0.1.1 

type IdentifierExpressionContext struct {
	ExpressionContext
}

func NewIdentifierExpressionContext added in v0.1.1 

func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext

func (*IdentifierExpressionContext) Accept added in v0.1.1 

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

func (*IdentifierExpressionContext) EnterRule added in v0.1.1 

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

func (*IdentifierExpressionContext) ExitRule added in v0.1.1 

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

func (*IdentifierExpressionContext) GetRuleContext added in v0.1.1 

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

func (*IdentifierExpressionContext) IDENTIFIER added in v0.1.1 

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

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) ARROW added in v0.1.3 

func (s *IfStatementContext) ARROW(i int) antlr.TerminalNode

func (*IfStatementContext) Accept 

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

func (*IfStatementContext) AllARROW added in v0.1.3 

func (s *IfStatementContext) AllARROW() []antlr.TerminalNode

func (*IfStatementContext) AllBlock 

func (s *IfStatementContext) AllBlock() []IBlockContext

func (*IfStatementContext) AllELSE 

func (s *IfStatementContext) AllELSE() []antlr.TerminalNode

func (*IfStatementContext) AllExpression 

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

func (*IfStatementContext) AllIF 

func (s *IfStatementContext) AllIF() []antlr.TerminalNode

func (*IfStatementContext) AllLPAREN 

func (s *IfStatementContext) AllLPAREN() []antlr.TerminalNode

func (*IfStatementContext) AllRPAREN 

func (s *IfStatementContext) AllRPAREN() []antlr.TerminalNode

func (*IfStatementContext) AllStatement added in v0.1.3 

func (s *IfStatementContext) AllStatement() []IStatementContext

func (*IfStatementContext) Block 

func (s *IfStatementContext) Block(i int) IBlockContext

func (*IfStatementContext) ELSE 

func (s *IfStatementContext) ELSE(i int) antlr.TerminalNode

func (*IfStatementContext) EnterRule 

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

func (*IfStatementContext) ExitRule 

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

func (*IfStatementContext) Expression 

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

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(i int) antlr.TerminalNode

func (*IfStatementContext) IsIfStatementContext 

func (*IfStatementContext) IsIfStatementContext()

func (*IfStatementContext) LPAREN 

func (s *IfStatementContext) LPAREN(i int) antlr.TerminalNode

func (*IfStatementContext) RPAREN 

func (s *IfStatementContext) RPAREN(i int) antlr.TerminalNode

func (*IfStatementContext) Statement added in v0.1.3 

func (s *IfStatementContext) Statement(i int) IStatementContext

func (*IfStatementContext) ToStringTree 

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

type ImportDeclarationContext 

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

func NewEmptyImportDeclarationContext 

func NewEmptyImportDeclarationContext() *ImportDeclarationContext

func NewImportDeclarationContext 

func NewImportDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDeclarationContext

func (*ImportDeclarationContext) Accept 

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

func (*ImportDeclarationContext) EnterRule 

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

func (*ImportDeclarationContext) ExitRule 

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

func (*ImportDeclarationContext) GetParser 

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

func (*ImportDeclarationContext) GetRuleContext 

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

func (*ImportDeclarationContext) IsImportDeclarationContext 

func (*ImportDeclarationContext) IsImportDeclarationContext()

func (*ImportDeclarationContext) SEMI 

func (s *ImportDeclarationContext) SEMI() antlr.TerminalNode

func (*ImportDeclarationContext) STRING_LITERAL 

func (s *ImportDeclarationContext) STRING_LITERAL() antlr.TerminalNode

func (*ImportDeclarationContext) ToStringTree 

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

func (*ImportDeclarationContext) USE added in v0.1.1 

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

type InterfaceDeclarationContext 

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

func NewEmptyInterfaceDeclarationContext 

func NewEmptyInterfaceDeclarationContext() *InterfaceDeclarationContext

func NewInterfaceDeclarationContext 

func NewInterfaceDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceDeclarationContext

func (*InterfaceDeclarationContext) Accept 

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

func (*InterfaceDeclarationContext) AllFunctionDeclaration 

func (s *InterfaceDeclarationContext) AllFunctionDeclaration() []IFunctionDeclarationContext

func (*InterfaceDeclarationContext) AllIDENTIFIER added in v0.1.8 

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

func (*InterfaceDeclarationContext) AllVariableDeclaration added in v0.1.7 

func (s *InterfaceDeclarationContext) AllVariableDeclaration() []IVariableDeclarationContext

func (*InterfaceDeclarationContext) EnterRule 

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

func (*InterfaceDeclarationContext) ExitRule 

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

func (*InterfaceDeclarationContext) FunctionDeclaration 

func (s *InterfaceDeclarationContext) FunctionDeclaration(i int) IFunctionDeclarationContext

func (*InterfaceDeclarationContext) GetParser 

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

func (*InterfaceDeclarationContext) GetRuleContext 

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

func (*InterfaceDeclarationContext) IDENTIFIER 

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

func (*InterfaceDeclarationContext) IMPLEMENTS added in v0.1.8 

func (s *InterfaceDeclarationContext) IMPLEMENTS() antlr.TerminalNode

func (*InterfaceDeclarationContext) INTERFACE 

func (s *InterfaceDeclarationContext) INTERFACE() antlr.TerminalNode

func (*InterfaceDeclarationContext) IsInterfaceDeclarationContext 

func (*InterfaceDeclarationContext) IsInterfaceDeclarationContext()

func (*InterfaceDeclarationContext) LBRACE 

func (s *InterfaceDeclarationContext) LBRACE() antlr.TerminalNode

func (*InterfaceDeclarationContext) RBRACE 

func (s *InterfaceDeclarationContext) RBRACE() antlr.TerminalNode

func (*InterfaceDeclarationContext) ToStringTree 

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

func (*InterfaceDeclarationContext) VariableDeclaration added in v0.1.7 

func (s *InterfaceDeclarationContext) VariableDeclaration(i int) IVariableDeclarationContext

type JsStatementContext added in v0.1.1 

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

func NewEmptyJsStatementContext added in v0.1.1 

func NewEmptyJsStatementContext() *JsStatementContext

func NewJsStatementContext added in v0.1.1 

func NewJsStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsStatementContext

func (*JsStatementContext) AT added in v0.1.1 

func (s *JsStatementContext) AT() antlr.TerminalNode

func (*JsStatementContext) Accept added in v0.1.1 

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

func (*JsStatementContext) EnterRule added in v0.1.1 

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

func (*JsStatementContext) ExitRule added in v0.1.1 

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

func (*JsStatementContext) GetParser added in v0.1.1 

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

func (*JsStatementContext) GetRuleContext added in v0.1.1 

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

func (*JsStatementContext) IsJsStatementContext added in v0.1.1 

func (*JsStatementContext) IsJsStatementContext()

func (*JsStatementContext) JS added in v0.1.1 

func (s *JsStatementContext) JS() antlr.TerminalNode

func (*JsStatementContext) SEMI added in v0.1.1 

func (s *JsStatementContext) SEMI() antlr.TerminalNode

func (*JsStatementContext) STRING_LITERAL added in v0.1.4 

func (s *JsStatementContext) STRING_LITERAL() antlr.TerminalNode

func (*JsStatementContext) ToStringTree added in v0.1.1 

func (s *JsStatementContext) 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) Accept 

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

func (*LiteralContext) ArrayLiteral added in v0.1.1 

func (s *LiteralContext) ArrayLiteral() IArrayLiteralContext

func (*LiteralContext) BOOL_LITERAL 

func (s *LiteralContext) BOOL_LITERAL() antlr.TerminalNode

func (*LiteralContext) EnterRule 

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

func (*LiteralContext) ExitRule 

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

func (*LiteralContext) FLOAT_LITERAL 

func (s *LiteralContext) FLOAT_LITERAL() antlr.TerminalNode

func (*LiteralContext) GetParser 

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

func (*LiteralContext) GetRuleContext 

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

func (*LiteralContext) INT_LITERAL 

func (s *LiteralContext) INT_LITERAL() antlr.TerminalNode

func (*LiteralContext) IsLiteralContext 

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) NULL_LITERAL added in v0.1.1 

func (s *LiteralContext) NULL_LITERAL() antlr.TerminalNode

func (*LiteralContext) ObjectLiteral added in v0.2.2 

func (s *LiteralContext) ObjectLiteral() IObjectLiteralContext

func (*LiteralContext) STRING_LITERAL 

func (s *LiteralContext) STRING_LITERAL() antlr.TerminalNode

func (*LiteralContext) ToStringTree 

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

type LiteralExpressionContext added in v0.1.1 

type LiteralExpressionContext struct {
	ExpressionContext
}

func NewLiteralExpressionContext added in v0.1.1 

func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext

func (*LiteralExpressionContext) Accept added in v0.1.1 

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

func (*LiteralExpressionContext) EnterRule added in v0.1.1 

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

func (*LiteralExpressionContext) ExitRule added in v0.1.1 

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

func (*LiteralExpressionContext) GetRuleContext added in v0.1.1 

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

func (*LiteralExpressionContext) Literal added in v0.1.1 

func (s *LiteralExpressionContext) Literal() ILiteralContext

type LogicalExpressionContext 

type LogicalExpressionContext struct {
	ExpressionContext
}

func NewLogicalExpressionContext 

func NewLogicalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalExpressionContext

func (*LogicalExpressionContext) AND 

func (s *LogicalExpressionContext) AND() antlr.TerminalNode

func (*LogicalExpressionContext) Accept 

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

func (*LogicalExpressionContext) AllExpression added in v0.1.1 

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

func (*LogicalExpressionContext) EnterRule 

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

func (*LogicalExpressionContext) ExitRule 

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

func (*LogicalExpressionContext) Expression added in v0.1.1 

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

func (*LogicalExpressionContext) GetRuleContext 

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

func (*LogicalExpressionContext) OR 

func (s *LogicalExpressionContext) OR() antlr.TerminalNode

type LoopStatementContext 

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

func NewEmptyLoopStatementContext 

func NewEmptyLoopStatementContext() *LoopStatementContext

func NewLoopStatementContext 

func NewLoopStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopStatementContext

func (*LoopStatementContext) Accept 

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

func (*LoopStatementContext) Block 

func (s *LoopStatementContext) Block() IBlockContext

func (*LoopStatementContext) EnterRule 

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

func (*LoopStatementContext) ExitRule 

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

func (*LoopStatementContext) GetParser 

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

func (*LoopStatementContext) GetRuleContext 

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

func (*LoopStatementContext) IsLoopStatementContext 

func (*LoopStatementContext) IsLoopStatementContext()

func (*LoopStatementContext) LOOP 

func (s *LoopStatementContext) LOOP() antlr.TerminalNode

func (*LoopStatementContext) ToStringTree 

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

type ModuleDeclarationContext 

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

func NewEmptyModuleDeclarationContext 

func NewEmptyModuleDeclarationContext() *ModuleDeclarationContext

func NewModuleDeclarationContext 

func NewModuleDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleDeclarationContext

func (*ModuleDeclarationContext) Accept 

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

func (*ModuleDeclarationContext) AllFunctionDeclaration 

func (s *ModuleDeclarationContext) AllFunctionDeclaration() []IFunctionDeclarationContext

func (*ModuleDeclarationContext) AllIDENTIFIER 

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

func (*ModuleDeclarationContext) AllTypeDeclaration 

func (s *ModuleDeclarationContext) AllTypeDeclaration() []ITypeDeclarationContext

func (*ModuleDeclarationContext) AllVariableDeclaration 

func (s *ModuleDeclarationContext) AllVariableDeclaration() []IVariableDeclarationContext

func (*ModuleDeclarationContext) EnterRule 

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

func (*ModuleDeclarationContext) ExitRule 

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

func (*ModuleDeclarationContext) FunctionDeclaration 

func (s *ModuleDeclarationContext) FunctionDeclaration(i int) IFunctionDeclarationContext

func (*ModuleDeclarationContext) GetParser 

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

func (*ModuleDeclarationContext) GetRuleContext 

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

func (*ModuleDeclarationContext) IDENTIFIER 

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

func (*ModuleDeclarationContext) IMPLEMENTS 

func (s *ModuleDeclarationContext) IMPLEMENTS() antlr.TerminalNode

func (*ModuleDeclarationContext) IsModuleDeclarationContext 

func (*ModuleDeclarationContext) IsModuleDeclarationContext()

func (*ModuleDeclarationContext) LBRACE 

func (s *ModuleDeclarationContext) LBRACE() antlr.TerminalNode

func (*ModuleDeclarationContext) MODULE 

func (s *ModuleDeclarationContext) MODULE() antlr.TerminalNode

func (*ModuleDeclarationContext) RBRACE 

func (s *ModuleDeclarationContext) RBRACE() antlr.TerminalNode

func (*ModuleDeclarationContext) ToStringTree 

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

func (*ModuleDeclarationContext) TypeDeclaration 

func (s *ModuleDeclarationContext) TypeDeclaration(i int) ITypeDeclarationContext

func (*ModuleDeclarationContext) VariableDeclaration 

func (s *ModuleDeclarationContext) VariableDeclaration(i int) IVariableDeclarationContext

type MultiplicativeExpressionContext 

type MultiplicativeExpressionContext struct {
	ExpressionContext
}

func NewMultiplicativeExpressionContext 

func NewMultiplicativeExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicativeExpressionContext

func (*MultiplicativeExpressionContext) Accept 

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

func (*MultiplicativeExpressionContext) AllExpression added in v0.1.1 

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

func (*MultiplicativeExpressionContext) DIV 

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

func (*MultiplicativeExpressionContext) EnterRule 

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

func (*MultiplicativeExpressionContext) ExitRule 

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

func (*MultiplicativeExpressionContext) Expression added in v0.1.1 

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

func (*MultiplicativeExpressionContext) GetRuleContext 

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

func (*MultiplicativeExpressionContext) MOD 

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

func (*MultiplicativeExpressionContext) MULT 

func (s *MultiplicativeExpressionContext) MULT() antlr.TerminalNode

type ObjectLiteralContext added in v0.2.2 

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

func NewEmptyObjectLiteralContext added in v0.2.2 

func NewEmptyObjectLiteralContext() *ObjectLiteralContext

func NewObjectLiteralContext added in v0.2.2 

func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext

func (*ObjectLiteralContext) ARROW added in v0.2.2 

func (s *ObjectLiteralContext) ARROW(i int) antlr.TerminalNode

func (*ObjectLiteralContext) Accept added in v0.2.2 

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

func (*ObjectLiteralContext) AllARROW added in v0.2.2 

func (s *ObjectLiteralContext) AllARROW() []antlr.TerminalNode

func (*ObjectLiteralContext) AllCOMMA added in v0.2.2 

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

func (*ObjectLiteralContext) AllExpression added in v0.2.2 

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

func (*ObjectLiteralContext) COMMA added in v0.2.2 

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

func (*ObjectLiteralContext) EnterRule added in v0.2.2 

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

func (*ObjectLiteralContext) ExitRule added in v0.2.2 

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

func (*ObjectLiteralContext) Expression added in v0.2.2 

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

func (*ObjectLiteralContext) GetParser added in v0.2.2 

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

func (*ObjectLiteralContext) GetRuleContext added in v0.2.2 

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

func (*ObjectLiteralContext) IsObjectLiteralContext added in v0.2.2 

func (*ObjectLiteralContext) IsObjectLiteralContext()

func (*ObjectLiteralContext) LBRACK added in v0.2.2 

func (s *ObjectLiteralContext) LBRACK() antlr.TerminalNode

func (*ObjectLiteralContext) RBRACK added in v0.2.2 

func (s *ObjectLiteralContext) RBRACK() antlr.TerminalNode

func (*ObjectLiteralContext) ToStringTree added in v0.2.2 

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

type ParameterContext 

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

func NewEmptyParameterContext 

func NewEmptyParameterContext() *ParameterContext

func NewParameterContext 

func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext

func (*ParameterContext) Accept 

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

func (*ParameterContext) EnterRule 

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

func (*ParameterContext) ExitRule 

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

func (*ParameterContext) GetParser 

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

func (*ParameterContext) GetRuleContext 

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

func (*ParameterContext) IDENTIFIER 

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

func (*ParameterContext) IsParameterContext 

func (*ParameterContext) IsParameterContext()

func (*ParameterContext) ToStringTree 

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

func (*ParameterContext) TypeExpression 

func (s *ParameterContext) TypeExpression() ITypeExpressionContext

type ParameterListContext 

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

func NewEmptyParameterListContext 

func NewEmptyParameterListContext() *ParameterListContext

func NewParameterListContext 

func NewParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterListContext

func (*ParameterListContext) Accept 

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

func (*ParameterListContext) AllCOMMA 

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

func (*ParameterListContext) AllParameter 

func (s *ParameterListContext) AllParameter() []IParameterContext

func (*ParameterListContext) COMMA 

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

func (*ParameterListContext) EnterRule 

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

func (*ParameterListContext) ExitRule 

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

func (*ParameterListContext) GetParser 

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

func (*ParameterListContext) GetRuleContext 

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

func (*ParameterListContext) IsParameterListContext 

func (*ParameterListContext) IsParameterListContext()

func (*ParameterListContext) Parameter 

func (s *ParameterListContext) Parameter(i int) IParameterContext

func (*ParameterListContext) ToStringTree 

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

type ParenthesisExpressionContext added in v0.1.1 

type ParenthesisExpressionContext struct {
	ExpressionContext
}

func NewParenthesisExpressionContext added in v0.1.1 

func NewParenthesisExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesisExpressionContext

func (*ParenthesisExpressionContext) Accept added in v0.1.1 

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

func (*ParenthesisExpressionContext) EnterRule added in v0.1.1 

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

func (*ParenthesisExpressionContext) ExitRule added in v0.1.1 

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

func (*ParenthesisExpressionContext) Expression added in v0.1.1 

func (s *ParenthesisExpressionContext) Expression() IExpressionContext

func (*ParenthesisExpressionContext) GetRuleContext added in v0.1.1 

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

func (*ParenthesisExpressionContext) LPAREN added in v0.1.1 

func (s *ParenthesisExpressionContext) LPAREN() antlr.TerminalNode

func (*ParenthesisExpressionContext) RPAREN added in v0.1.1 

func (s *ParenthesisExpressionContext) RPAREN() antlr.TerminalNode

type ProgramContext 

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

func NewEmptyProgramContext 

func NewEmptyProgramContext() *ProgramContext

func NewProgramContext 

func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

func (*ProgramContext) Accept 

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

func (*ProgramContext) AllDeclaration 

func (s *ProgramContext) AllDeclaration() []IDeclarationContext

func (*ProgramContext) AllImportDeclaration 

func (s *ProgramContext) AllImportDeclaration() []IImportDeclarationContext

func (*ProgramContext) AllInterfaceDeclaration added in v0.1.7 

func (s *ProgramContext) AllInterfaceDeclaration() []IInterfaceDeclarationContext

func (*ProgramContext) Declaration 

func (s *ProgramContext) Declaration(i int) IDeclarationContext

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

func (s *ProgramContext) ImportDeclaration(i int) IImportDeclarationContext

func (*ProgramContext) InterfaceDeclaration added in v0.1.7 

func (s *ProgramContext) InterfaceDeclaration(i int) IInterfaceDeclarationContext

func (*ProgramContext) IsProgramContext 

func (*ProgramContext) IsProgramContext()

func (*ProgramContext) ToStringTree 

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

type R2D2ErrorListener 

type R2D2ErrorListener struct {
	*antlr.DefaultErrorListener
	ErrorCollector *errors.ErrorCollector
}

R2D2ErrorListener is a listener that listens to errors emitted by the parser.

func NewR2D2ErrorListener 

func NewR2D2ErrorListener(errorCollector *errors.ErrorCollector) *R2D2ErrorListener

func (*R2D2ErrorListener) SyntaxError 

func (l *R2D2ErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol any, line, column int, msg string, e antlr.RecognitionException)

type R2D2Lexer 

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

func NewR2D2Lexer 

func NewR2D2Lexer(input antlr.CharStream) *R2D2Lexer

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

type R2D2Listener 

type R2D2Listener interface {
	antlr.ParseTreeListener

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

	// EnterDeclaration is called when entering the declaration production.
	EnterDeclaration(c *DeclarationContext)

	// EnterGlobalDeclaration is called when entering the globalDeclaration production.
	EnterGlobalDeclaration(c *GlobalDeclarationContext)

	// EnterImportDeclaration is called when entering the importDeclaration production.
	EnterImportDeclaration(c *ImportDeclarationContext)

	// EnterInterfaceDeclaration is called when entering the interfaceDeclaration production.
	EnterInterfaceDeclaration(c *InterfaceDeclarationContext)

	// EnterModuleDeclaration is called when entering the moduleDeclaration production.
	EnterModuleDeclaration(c *ModuleDeclarationContext)

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

	// EnterFunctionCallStatement is called when entering the functionCallStatement production.
	EnterFunctionCallStatement(c *FunctionCallStatementContext)

	// EnterFunctionCall is called when entering the functionCall production.
	EnterFunctionCall(c *FunctionCallContext)

	// EnterParameterList is called when entering the parameterList production.
	EnterParameterList(c *ParameterListContext)

	// EnterParameter is called when entering the parameter production.
	EnterParameter(c *ParameterContext)

	// EnterTypeExpression is called when entering the typeExpression production.
	EnterTypeExpression(c *TypeExpressionContext)

	// EnterArrayDimensions is called when entering the arrayDimensions production.
	EnterArrayDimensions(c *ArrayDimensionsContext)

	// EnterBaseType is called when entering the baseType production.
	EnterBaseType(c *BaseTypeContext)

	// EnterGenericType is called when entering the genericType production.
	EnterGenericType(c *GenericTypeContext)

	// EnterTypeDeclaration is called when entering the typeDeclaration production.
	EnterTypeDeclaration(c *TypeDeclarationContext)

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

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

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

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

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

	// EnterAssignmentDeclaration is called when entering the assignmentDeclaration production.
	EnterAssignmentDeclaration(c *AssignmentDeclarationContext)

	// EnterAssignment is called when entering the assignment production.
	EnterAssignment(c *AssignmentContext)

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

	// EnterSimpleFor is called when entering the simpleFor production.
	EnterSimpleFor(c *SimpleForContext)

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

	// EnterLoopStatement is called when entering the loopStatement production.
	EnterLoopStatement(c *LoopStatementContext)

	// EnterCicleControl is called when entering the cicleControl production.
	EnterCicleControl(c *CicleControlContext)

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

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

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

	// EnterArrayAccessExpression is called when entering the arrayAccessExpression production.
	EnterArrayAccessExpression(c *ArrayAccessExpressionContext)

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

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

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

	// EnterParenthesisExpression is called when entering the parenthesisExpression production.
	EnterParenthesisExpression(c *ParenthesisExpressionContext)

	// EnterComparisonExpression is called when entering the comparisonExpression production.
	EnterComparisonExpression(c *ComparisonExpressionContext)

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

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

	// EnterUnaryExpression is called when entering the unaryExpression production.
	EnterUnaryExpression(c *UnaryExpressionContext)

	// EnterLogicalExpression is called when entering the logicalExpression production.
	EnterLogicalExpression(c *LogicalExpressionContext)

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

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

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

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

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

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

	// EnterSwitchCase is called when entering the switchCase production.
	EnterSwitchCase(c *SwitchCaseContext)

	// EnterDefaultCase is called when entering the defaultCase production.
	EnterDefaultCase(c *DefaultCaseContext)

	// EnterJsStatement is called when entering the jsStatement production.
	EnterJsStatement(c *JsStatementContext)

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

	// ExitDeclaration is called when exiting the declaration production.
	ExitDeclaration(c *DeclarationContext)

	// ExitGlobalDeclaration is called when exiting the globalDeclaration production.
	ExitGlobalDeclaration(c *GlobalDeclarationContext)

	// ExitImportDeclaration is called when exiting the importDeclaration production.
	ExitImportDeclaration(c *ImportDeclarationContext)

	// ExitInterfaceDeclaration is called when exiting the interfaceDeclaration production.
	ExitInterfaceDeclaration(c *InterfaceDeclarationContext)

	// ExitModuleDeclaration is called when exiting the moduleDeclaration production.
	ExitModuleDeclaration(c *ModuleDeclarationContext)

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

	// ExitFunctionCallStatement is called when exiting the functionCallStatement production.
	ExitFunctionCallStatement(c *FunctionCallStatementContext)

	// ExitFunctionCall is called when exiting the functionCall production.
	ExitFunctionCall(c *FunctionCallContext)

	// ExitParameterList is called when exiting the parameterList production.
	ExitParameterList(c *ParameterListContext)

	// ExitParameter is called when exiting the parameter production.
	ExitParameter(c *ParameterContext)

	// ExitTypeExpression is called when exiting the typeExpression production.
	ExitTypeExpression(c *TypeExpressionContext)

	// ExitArrayDimensions is called when exiting the arrayDimensions production.
	ExitArrayDimensions(c *ArrayDimensionsContext)

	// ExitBaseType is called when exiting the baseType production.
	ExitBaseType(c *BaseTypeContext)

	// ExitGenericType is called when exiting the genericType production.
	ExitGenericType(c *GenericTypeContext)

	// ExitTypeDeclaration is called when exiting the typeDeclaration production.
	ExitTypeDeclaration(c *TypeDeclarationContext)

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

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

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

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

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

	// ExitAssignmentDeclaration is called when exiting the assignmentDeclaration production.
	ExitAssignmentDeclaration(c *AssignmentDeclarationContext)

	// ExitAssignment is called when exiting the assignment production.
	ExitAssignment(c *AssignmentContext)

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

	// ExitSimpleFor is called when exiting the simpleFor production.
	ExitSimpleFor(c *SimpleForContext)

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

	// ExitLoopStatement is called when exiting the loopStatement production.
	ExitLoopStatement(c *LoopStatementContext)

	// ExitCicleControl is called when exiting the cicleControl production.
	ExitCicleControl(c *CicleControlContext)

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

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

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

	// ExitArrayAccessExpression is called when exiting the arrayAccessExpression production.
	ExitArrayAccessExpression(c *ArrayAccessExpressionContext)

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

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

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

	// ExitParenthesisExpression is called when exiting the parenthesisExpression production.
	ExitParenthesisExpression(c *ParenthesisExpressionContext)

	// ExitComparisonExpression is called when exiting the comparisonExpression production.
	ExitComparisonExpression(c *ComparisonExpressionContext)

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

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

	// ExitUnaryExpression is called when exiting the unaryExpression production.
	ExitUnaryExpression(c *UnaryExpressionContext)

	// ExitLogicalExpression is called when exiting the logicalExpression production.
	ExitLogicalExpression(c *LogicalExpressionContext)

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

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

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

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

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

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

	// ExitSwitchCase is called when exiting the switchCase production.
	ExitSwitchCase(c *SwitchCaseContext)

	// ExitDefaultCase is called when exiting the defaultCase production.
	ExitDefaultCase(c *DefaultCaseContext)

	// ExitJsStatement is called when exiting the jsStatement production.
	ExitJsStatement(c *JsStatementContext)
}

R2D2Listener is a complete listener for a parse tree produced by R2D2Parser.

type R2D2Parser 

type R2D2Parser struct {
	*antlr.BaseParser
}

func NewR2D2Parser 

func NewR2D2Parser(input antlr.TokenStream) *R2D2Parser

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

func (*R2D2Parser) ArgumentList 

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

func (*R2D2Parser) ArrayDimensions 

func (p *R2D2Parser) ArrayDimensions() (localctx IArrayDimensionsContext)

func (*R2D2Parser) ArrayLiteral 

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

func (*R2D2Parser) Assignment 

func (p *R2D2Parser) Assignment() (localctx IAssignmentContext)

func (*R2D2Parser) AssignmentDeclaration 

func (p *R2D2Parser) AssignmentDeclaration() (localctx IAssignmentDeclarationContext)

func (*R2D2Parser) AssignmentOperator 

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

func (*R2D2Parser) BaseType 

func (p *R2D2Parser) BaseType() (localctx IBaseTypeContext)

func (*R2D2Parser) Block 

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

func (*R2D2Parser) BreakStatement 

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

func (*R2D2Parser) CicleControl 

func (p *R2D2Parser) CicleControl() (localctx ICicleControlContext)

func (*R2D2Parser) ContinueStatement 

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

func (*R2D2Parser) Declaration 

func (p *R2D2Parser) Declaration() (localctx IDeclarationContext)

func (*R2D2Parser) DefaultCase 

func (p *R2D2Parser) DefaultCase() (localctx IDefaultCaseContext)

func (*R2D2Parser) Expression 

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

func (*R2D2Parser) ExpressionStatement 

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

func (*R2D2Parser) Expression_Sempred added in v0.1.1 

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

func (*R2D2Parser) ForStatement 

func (p *R2D2Parser) ForStatement() (localctx IForStatementContext)

func (*R2D2Parser) FunctionCall 

func (p *R2D2Parser) FunctionCall() (localctx IFunctionCallContext)

func (*R2D2Parser) FunctionCallStatement 

func (p *R2D2Parser) FunctionCallStatement() (localctx IFunctionCallStatementContext)

func (*R2D2Parser) FunctionDeclaration 

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

func (*R2D2Parser) GenericType 

func (p *R2D2Parser) GenericType() (localctx IGenericTypeContext)

func (*R2D2Parser) GlobalDeclaration 

func (p *R2D2Parser) GlobalDeclaration() (localctx IGlobalDeclarationContext)

func (*R2D2Parser) IfStatement 

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

func (*R2D2Parser) ImportDeclaration 

func (p *R2D2Parser) ImportDeclaration() (localctx IImportDeclarationContext)

func (*R2D2Parser) InterfaceDeclaration 

func (p *R2D2Parser) InterfaceDeclaration() (localctx IInterfaceDeclarationContext)

func (*R2D2Parser) JsStatement added in v0.1.1 

func (p *R2D2Parser) JsStatement() (localctx IJsStatementContext)

func (*R2D2Parser) Literal 

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

func (*R2D2Parser) LoopStatement 

func (p *R2D2Parser) LoopStatement() (localctx ILoopStatementContext)

func (*R2D2Parser) ModuleDeclaration 

func (p *R2D2Parser) ModuleDeclaration() (localctx IModuleDeclarationContext)

func (*R2D2Parser) ObjectLiteral added in v0.2.2 

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

func (*R2D2Parser) Parameter 

func (p *R2D2Parser) Parameter() (localctx IParameterContext)

func (*R2D2Parser) ParameterList 

func (p *R2D2Parser) ParameterList() (localctx IParameterListContext)

func (*R2D2Parser) Program 

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

func (*R2D2Parser) ReturnStatement 

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

func (*R2D2Parser) Sempred added in v0.1.1 

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

func (*R2D2Parser) SimpleFor 

func (p *R2D2Parser) SimpleFor() (localctx ISimpleForContext)

func (*R2D2Parser) Statement 

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

func (*R2D2Parser) SwitchCase 

func (p *R2D2Parser) SwitchCase() (localctx ISwitchCaseContext)

func (*R2D2Parser) SwitchStatement 

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

func (*R2D2Parser) TypeDeclaration 

func (p *R2D2Parser) TypeDeclaration() (localctx ITypeDeclarationContext)

func (*R2D2Parser) TypeExpression 

func (p *R2D2Parser) TypeExpression() (localctx ITypeExpressionContext)

func (*R2D2Parser) VariableDeclaration 

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

func (*R2D2Parser) WhileStatement 

func (p *R2D2Parser) WhileStatement() (localctx IWhileStatementContext)

type R2D2Visitor 

type R2D2Visitor interface {
	antlr.ParseTreeVisitor

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

	// Visit a parse tree produced by R2D2Parser#declaration.
	VisitDeclaration(ctx *DeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#globalDeclaration.
	VisitGlobalDeclaration(ctx *GlobalDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#importDeclaration.
	VisitImportDeclaration(ctx *ImportDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#interfaceDeclaration.
	VisitInterfaceDeclaration(ctx *InterfaceDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#moduleDeclaration.
	VisitModuleDeclaration(ctx *ModuleDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#functionDeclaration.
	VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#functionCallStatement.
	VisitFunctionCallStatement(ctx *FunctionCallStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#functionCall.
	VisitFunctionCall(ctx *FunctionCallContext) interface{}

	// Visit a parse tree produced by R2D2Parser#parameterList.
	VisitParameterList(ctx *ParameterListContext) interface{}

	// Visit a parse tree produced by R2D2Parser#parameter.
	VisitParameter(ctx *ParameterContext) interface{}

	// Visit a parse tree produced by R2D2Parser#typeExpression.
	VisitTypeExpression(ctx *TypeExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#arrayDimensions.
	VisitArrayDimensions(ctx *ArrayDimensionsContext) interface{}

	// Visit a parse tree produced by R2D2Parser#baseType.
	VisitBaseType(ctx *BaseTypeContext) interface{}

	// Visit a parse tree produced by R2D2Parser#genericType.
	VisitGenericType(ctx *GenericTypeContext) interface{}

	// Visit a parse tree produced by R2D2Parser#typeDeclaration.
	VisitTypeDeclaration(ctx *TypeDeclarationContext) interface{}

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

	// Visit a parse tree produced by R2D2Parser#statement.
	VisitStatement(ctx *StatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#expressionStatement.
	VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#ifStatement.
	VisitIfStatement(ctx *IfStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#forStatement.
	VisitForStatement(ctx *ForStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#assignmentDeclaration.
	VisitAssignmentDeclaration(ctx *AssignmentDeclarationContext) interface{}

	// Visit a parse tree produced by R2D2Parser#assignment.
	VisitAssignment(ctx *AssignmentContext) interface{}

	// Visit a parse tree produced by R2D2Parser#assignmentOperator.
	VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}

	// Visit a parse tree produced by R2D2Parser#simpleFor.
	VisitSimpleFor(ctx *SimpleForContext) interface{}

	// Visit a parse tree produced by R2D2Parser#whileStatement.
	VisitWhileStatement(ctx *WhileStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#loopStatement.
	VisitLoopStatement(ctx *LoopStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#cicleControl.
	VisitCicleControl(ctx *CicleControlContext) interface{}

	// Visit a parse tree produced by R2D2Parser#breakStatement.
	VisitBreakStatement(ctx *BreakStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#continueStatement.
	VisitContinueStatement(ctx *ContinueStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#returnStatement.
	VisitReturnStatement(ctx *ReturnStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#arrayAccessExpression.
	VisitArrayAccessExpression(ctx *ArrayAccessExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#additiveExpression.
	VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#identifierExpression.
	VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

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

	// Visit a parse tree produced by R2D2Parser#parenthesisExpression.
	VisitParenthesisExpression(ctx *ParenthesisExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#comparisonExpression.
	VisitComparisonExpression(ctx *ComparisonExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#multiplicativeExpression.
	VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#literalExpression.
	VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#unaryExpression.
	VisitUnaryExpression(ctx *UnaryExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#logicalExpression.
	VisitLogicalExpression(ctx *LogicalExpressionContext) interface{}

	// Visit a parse tree produced by R2D2Parser#argumentList.
	VisitArgumentList(ctx *ArgumentListContext) interface{}

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

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

	// Visit a parse tree produced by R2D2Parser#literal.
	VisitLiteral(ctx *LiteralContext) interface{}

	// Visit a parse tree produced by R2D2Parser#block.
	VisitBlock(ctx *BlockContext) interface{}

	// Visit a parse tree produced by R2D2Parser#switchStatement.
	VisitSwitchStatement(ctx *SwitchStatementContext) interface{}

	// Visit a parse tree produced by R2D2Parser#switchCase.
	VisitSwitchCase(ctx *SwitchCaseContext) interface{}

	// Visit a parse tree produced by R2D2Parser#defaultCase.
	VisitDefaultCase(ctx *DefaultCaseContext) interface{}

	// Visit a parse tree produced by R2D2Parser#jsStatement.
	VisitJsStatement(ctx *JsStatementContext) interface{}
}

A complete Visitor for a parse tree produced by R2D2Parser.

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

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

func (*ReturnStatementContext) EnterRule 

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

func (*ReturnStatementContext) ExitRule 

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

func (*ReturnStatementContext) Expression 

func (s *ReturnStatementContext) Expression() IExpressionContext

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

func (s *ReturnStatementContext) SEMI() antlr.TerminalNode

func (*ReturnStatementContext) ToStringTree 

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

type SimpleForContext 

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

func NewEmptySimpleForContext 

func NewEmptySimpleForContext() *SimpleForContext

func NewSimpleForContext 

func NewSimpleForContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleForContext

func (*SimpleForContext) Accept 

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

func (*SimpleForContext) AllAssignment 

func (s *SimpleForContext) AllAssignment() []IAssignmentContext

func (*SimpleForContext) AllSEMI added in v0.1.0 

func (s *SimpleForContext) AllSEMI() []antlr.TerminalNode

func (*SimpleForContext) Assignment 

func (s *SimpleForContext) Assignment(i int) IAssignmentContext

func (*SimpleForContext) EnterRule 

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

func (*SimpleForContext) ExitRule 

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

func (*SimpleForContext) Expression 

func (s *SimpleForContext) Expression() IExpressionContext

func (*SimpleForContext) GetParser 

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

func (*SimpleForContext) GetRuleContext 

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

func (*SimpleForContext) IsSimpleForContext 

func (*SimpleForContext) IsSimpleForContext()

func (*SimpleForContext) SEMI 

func (s *SimpleForContext) SEMI(i int) antlr.TerminalNode

func (*SimpleForContext) ToStringTree 

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

func (*SimpleForContext) VariableDeclaration 

func (s *SimpleForContext) VariableDeclaration() IVariableDeclarationContext

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

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

func (*StatementContext) AssignmentDeclaration 

func (s *StatementContext) AssignmentDeclaration() IAssignmentDeclarationContext

func (*StatementContext) CicleControl 

func (s *StatementContext) CicleControl() ICicleControlContext

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

func (s *StatementContext) ForStatement() IForStatementContext

func (*StatementContext) FunctionCallStatement 

func (s *StatementContext) FunctionCallStatement() IFunctionCallStatementContext

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) JsStatement added in v0.1.1 

func (s *StatementContext) JsStatement() IJsStatementContext

func (*StatementContext) LoopStatement 

func (s *StatementContext) LoopStatement() ILoopStatementContext

func (*StatementContext) ReturnStatement 

func (s *StatementContext) ReturnStatement() IReturnStatementContext

func (*StatementContext) SwitchStatement 

func (s *StatementContext) SwitchStatement() ISwitchStatementContext

func (*StatementContext) ToStringTree 

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

func (*StatementContext) VariableDeclaration 

func (s *StatementContext) VariableDeclaration() IVariableDeclarationContext

func (*StatementContext) WhileStatement 

func (s *StatementContext) WhileStatement() IWhileStatementContext

type SwitchCaseContext 

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

func NewEmptySwitchCaseContext 

func NewEmptySwitchCaseContext() *SwitchCaseContext

func NewSwitchCaseContext 

func NewSwitchCaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchCaseContext

func (*SwitchCaseContext) ARROW added in v0.1.3 

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

func (*SwitchCaseContext) Accept 

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

func (*SwitchCaseContext) Block 

func (s *SwitchCaseContext) Block() IBlockContext

func (*SwitchCaseContext) CASE 

func (s *SwitchCaseContext) CASE() antlr.TerminalNode

func (*SwitchCaseContext) EnterRule 

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

func (*SwitchCaseContext) ExitRule 

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

func (*SwitchCaseContext) Expression 

func (s *SwitchCaseContext) Expression() IExpressionContext

func (*SwitchCaseContext) GetParser 

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

func (*SwitchCaseContext) GetRuleContext 

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

func (*SwitchCaseContext) IsSwitchCaseContext 

func (*SwitchCaseContext) IsSwitchCaseContext()

func (*SwitchCaseContext) Statement added in v0.1.3 

func (s *SwitchCaseContext) Statement() IStatementContext

func (*SwitchCaseContext) ToStringTree 

func (s *SwitchCaseContext) 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) Accept 

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

func (*SwitchStatementContext) AllSwitchCase 

func (s *SwitchStatementContext) AllSwitchCase() []ISwitchCaseContext

func (*SwitchStatementContext) DefaultCase 

func (s *SwitchStatementContext) DefaultCase() IDefaultCaseContext

func (*SwitchStatementContext) EnterRule 

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

func (*SwitchStatementContext) ExitRule 

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

func (*SwitchStatementContext) Expression 

func (s *SwitchStatementContext) Expression() IExpressionContext

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

func (s *SwitchStatementContext) LBRACE() antlr.TerminalNode

func (*SwitchStatementContext) LPAREN 

func (s *SwitchStatementContext) LPAREN() antlr.TerminalNode

func (*SwitchStatementContext) RBRACE 

func (s *SwitchStatementContext) RBRACE() antlr.TerminalNode

func (*SwitchStatementContext) RPAREN 

func (s *SwitchStatementContext) RPAREN() antlr.TerminalNode

func (*SwitchStatementContext) SWITCH 

func (s *SwitchStatementContext) SWITCH() antlr.TerminalNode

func (*SwitchStatementContext) SwitchCase 

func (s *SwitchStatementContext) SwitchCase(i int) ISwitchCaseContext

func (*SwitchStatementContext) ToStringTree 

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

type TypeDeclarationContext 

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

func NewEmptyTypeDeclarationContext 

func NewEmptyTypeDeclarationContext() *TypeDeclarationContext

func NewTypeDeclarationContext 

func NewTypeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeDeclarationContext

func (*TypeDeclarationContext) Accept 

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

func (*TypeDeclarationContext) AllVariableDeclaration 

func (s *TypeDeclarationContext) AllVariableDeclaration() []IVariableDeclarationContext

func (*TypeDeclarationContext) EXPORT added in v0.1.0 

func (s *TypeDeclarationContext) EXPORT() antlr.TerminalNode

func (*TypeDeclarationContext) EnterRule 

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

func (*TypeDeclarationContext) ExitRule 

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

func (*TypeDeclarationContext) GetParser 

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

func (*TypeDeclarationContext) GetRuleContext 

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

func (*TypeDeclarationContext) IDENTIFIER 

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

func (*TypeDeclarationContext) IsTypeDeclarationContext 

func (*TypeDeclarationContext) IsTypeDeclarationContext()

func (*TypeDeclarationContext) LBRACE 

func (s *TypeDeclarationContext) LBRACE() antlr.TerminalNode

func (*TypeDeclarationContext) RBRACE 

func (s *TypeDeclarationContext) RBRACE() antlr.TerminalNode

func (*TypeDeclarationContext) ToStringTree 

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

func (*TypeDeclarationContext) VariableDeclaration 

func (s *TypeDeclarationContext) VariableDeclaration(i int) IVariableDeclarationContext

type TypeExpressionContext 

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

func NewEmptyTypeExpressionContext 

func NewEmptyTypeExpressionContext() *TypeExpressionContext

func NewTypeExpressionContext 

func NewTypeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeExpressionContext

func (*TypeExpressionContext) Accept 

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

func (*TypeExpressionContext) ArrayDimensions 

func (s *TypeExpressionContext) ArrayDimensions() IArrayDimensionsContext

func (*TypeExpressionContext) BaseType 

func (s *TypeExpressionContext) BaseType() IBaseTypeContext

func (*TypeExpressionContext) EnterRule 

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

func (*TypeExpressionContext) ExitRule 

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

func (*TypeExpressionContext) GetParser 

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

func (*TypeExpressionContext) GetRuleContext 

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

func (*TypeExpressionContext) IsTypeExpressionContext 

func (*TypeExpressionContext) IsTypeExpressionContext()

func (*TypeExpressionContext) ToStringTree 

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

type UnaryExpressionContext 

type UnaryExpressionContext struct {
	ExpressionContext
}

func NewUnaryExpressionContext 

func NewUnaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryExpressionContext

func (*UnaryExpressionContext) Accept 

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

func (*UnaryExpressionContext) DECREMENT 

func (s *UnaryExpressionContext) DECREMENT() antlr.TerminalNode

func (*UnaryExpressionContext) EnterRule 

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

func (*UnaryExpressionContext) ExitRule 

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

func (*UnaryExpressionContext) Expression added in v0.1.1 

func (s *UnaryExpressionContext) Expression() IExpressionContext

func (*UnaryExpressionContext) GetRuleContext 

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

func (*UnaryExpressionContext) INCREMENT 

func (s *UnaryExpressionContext) INCREMENT() antlr.TerminalNode

func (*UnaryExpressionContext) MINUS 

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

func (*UnaryExpressionContext) NOT 

func (s *UnaryExpressionContext) NOT() antlr.TerminalNode

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

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

func (*VariableDeclarationContext) Accept 

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

func (*VariableDeclarationContext) CONST 

func (s *VariableDeclarationContext) CONST() antlr.TerminalNode

func (*VariableDeclarationContext) EXPORT 

func (s *VariableDeclarationContext) EXPORT() antlr.TerminalNode

func (*VariableDeclarationContext) EnterRule 

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

func (*VariableDeclarationContext) ExitRule 

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

func (*VariableDeclarationContext) Expression 

func (s *VariableDeclarationContext) Expression() IExpressionContext

func (*VariableDeclarationContext) GetParser 

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

func (*VariableDeclarationContext) GetRuleContext 

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

func (*VariableDeclarationContext) IDENTIFIER 

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

func (*VariableDeclarationContext) IsVariableDeclarationContext 

func (*VariableDeclarationContext) IsVariableDeclarationContext()

func (*VariableDeclarationContext) LET 

func (s *VariableDeclarationContext) LET() antlr.TerminalNode

func (*VariableDeclarationContext) SEMI 

func (s *VariableDeclarationContext) SEMI() antlr.TerminalNode

func (*VariableDeclarationContext) ToStringTree 

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

func (*VariableDeclarationContext) TypeExpression 

func (s *VariableDeclarationContext) TypeExpression() ITypeExpressionContext

func (*VariableDeclarationContext) VAR 

func (s *VariableDeclarationContext) VAR() antlr.TerminalNode

type WhileStatementContext 

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

func NewEmptyWhileStatementContext 

func NewEmptyWhileStatementContext() *WhileStatementContext

func NewWhileStatementContext 

func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext

func (*WhileStatementContext) Accept 

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

func (*WhileStatementContext) Block 

func (s *WhileStatementContext) Block() IBlockContext

func (*WhileStatementContext) EnterRule 

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

func (*WhileStatementContext) ExitRule 

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

func (*WhileStatementContext) Expression 

func (s *WhileStatementContext) Expression() IExpressionContext

func (*WhileStatementContext) GetParser 

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

func (*WhileStatementContext) GetRuleContext 

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

func (*WhileStatementContext) IsWhileStatementContext 

func (*WhileStatementContext) IsWhileStatementContext()

func (*WhileStatementContext) LPAREN 

func (s *WhileStatementContext) LPAREN() antlr.TerminalNode

func (*WhileStatementContext) RPAREN 

func (s *WhileStatementContext) RPAREN() antlr.TerminalNode

func (*WhileStatementContext) ToStringTree 

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

func (*WhileStatementContext) WHILE 

func (s *WhileStatementContext) WHILE() 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.