parser

package
v1.3.2 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const (
	NaslLexerSingleLineComment          = 1
	NaslLexerOpenBracket                = 2
	NaslLexerCloseBracket               = 3
	NaslLexerOpenParen                  = 4
	NaslLexerCloseParen                 = 5
	NaslLexerOpenBrace                  = 6
	NaslLexerCloseBrace                 = 7
	NaslLexerSemiColon                  = 8
	NaslLexerComma                      = 9
	NaslLexerAssign                     = 10
	NaslLexerColon                      = 11
	NaslLexerDot                        = 12
	NaslLexerPlusPlus                   = 13
	NaslLexerMinusMinus                 = 14
	NaslLexerPlus                       = 15
	NaslLexerMinus                      = 16
	NaslLexerBitNot                     = 17
	NaslLexerBitAnd                     = 18
	NaslLexerBitXOr                     = 19
	NaslLexerBitOr                      = 20
	NaslLexerRightShiftArithmetic       = 21
	NaslLexerLeftShiftArithmetic        = 22
	NaslLexerRightShiftLogical          = 23
	NaslLexerNot                        = 24
	NaslLexerMultiply                   = 25
	NaslLexerPow                        = 26
	NaslLexerDivide                     = 27
	NaslLexerModulus                    = 28
	NaslLexerLessThan                   = 29
	NaslLexerMoreThan                   = 30
	NaslLexerLessThanEquals             = 31
	NaslLexerGreaterThanEquals          = 32
	NaslLexerEquals_                    = 33
	NaslLexerEqualsRe                   = 34
	NaslLexerNotEquals                  = 35
	NaslLexerNotLong                    = 36
	NaslLexerMTNotLT                    = 37
	NaslLexerMTLT                       = 38
	NaslLexerAnd                        = 39
	NaslLexerOr                         = 40
	NaslLexerMultiplyAssign             = 41
	NaslLexerDivideAssign               = 42
	NaslLexerModulusAssign              = 43
	NaslLexerPlusAssign                 = 44
	NaslLexerMinusAssign                = 45
	NaslLexerX                          = 46
	NaslLexerRightShiftLogicalAssign    = 47
	NaslLexerRightShiftArithmeticAssign = 48
	NaslLexerBreak                      = 49
	NaslLexerLocalVar                   = 50
	NaslLexerGlobalVar                  = 51
	NaslLexerElse                       = 52
	NaslLexerReturn                     = 53
	NaslLexerContinue                   = 54
	NaslLexerFor                        = 55
	NaslLexerForEach                    = 56
	NaslLexerIf                         = 57
	NaslLexerFunction_                  = 58
	NaslLexerRepeat                     = 59
	NaslLexerWhile                      = 60
	NaslLexerUntil                      = 61
	NaslLexerExit                       = 62
	NaslLexerStringLiteral              = 63
	NaslLexerBooleanLiteral             = 64
	NaslLexerIntegerLiteral             = 65
	NaslLexerFloatLiteral               = 66
	NaslLexerIpLiteral                  = 67
	NaslLexerHexLiteral                 = 68
	NaslLexerNULLLiteral                = 69
	NaslLexerIdentifier                 = 70
	NaslLexerWhiteSpaces                = 71
	NaslLexerLineTerminator             = 72
)

NaslLexer tokens.

View Source 
const (
	NaslParserEOF                        = antlr.TokenEOF
	NaslParserSingleLineComment          = 1
	NaslParserOpenBracket                = 2
	NaslParserCloseBracket               = 3
	NaslParserOpenParen                  = 4
	NaslParserCloseParen                 = 5
	NaslParserOpenBrace                  = 6
	NaslParserCloseBrace                 = 7
	NaslParserSemiColon                  = 8
	NaslParserComma                      = 9
	NaslParserAssign                     = 10
	NaslParserColon                      = 11
	NaslParserDot                        = 12
	NaslParserPlusPlus                   = 13
	NaslParserMinusMinus                 = 14
	NaslParserPlus                       = 15
	NaslParserMinus                      = 16
	NaslParserBitNot                     = 17
	NaslParserBitAnd                     = 18
	NaslParserBitXOr                     = 19
	NaslParserBitOr                      = 20
	NaslParserRightShiftArithmetic       = 21
	NaslParserLeftShiftArithmetic        = 22
	NaslParserRightShiftLogical          = 23
	NaslParserNot                        = 24
	NaslParserMultiply                   = 25
	NaslParserPow                        = 26
	NaslParserDivide                     = 27
	NaslParserModulus                    = 28
	NaslParserLessThan                   = 29
	NaslParserMoreThan                   = 30
	NaslParserLessThanEquals             = 31
	NaslParserGreaterThanEquals          = 32
	NaslParserEquals_                    = 33
	NaslParserEqualsRe                   = 34
	NaslParserNotEquals                  = 35
	NaslParserNotLong                    = 36
	NaslParserMTNotLT                    = 37
	NaslParserMTLT                       = 38
	NaslParserAnd                        = 39
	NaslParserOr                         = 40
	NaslParserMultiplyAssign             = 41
	NaslParserDivideAssign               = 42
	NaslParserModulusAssign              = 43
	NaslParserPlusAssign                 = 44
	NaslParserMinusAssign                = 45
	NaslParserX                          = 46
	NaslParserRightShiftLogicalAssign    = 47
	NaslParserRightShiftArithmeticAssign = 48
	NaslParserBreak                      = 49
	NaslParserLocalVar                   = 50
	NaslParserGlobalVar                  = 51
	NaslParserElse                       = 52
	NaslParserReturn                     = 53
	NaslParserContinue                   = 54
	NaslParserFor                        = 55
	NaslParserForEach                    = 56
	NaslParserIf                         = 57
	NaslParserFunction_                  = 58
	NaslParserRepeat                     = 59
	NaslParserWhile                      = 60
	NaslParserUntil                      = 61
	NaslParserExit                       = 62
	NaslParserStringLiteral              = 63
	NaslParserBooleanLiteral             = 64
	NaslParserIntegerLiteral             = 65
	NaslParserFloatLiteral               = 66
	NaslParserIpLiteral                  = 67
	NaslParserHexLiteral                 = 68
	NaslParserNULLLiteral                = 69
	NaslParserIdentifier                 = 70
	NaslParserWhiteSpaces                = 71
	NaslParserLineTerminator             = 72
)

NaslParser tokens.

View Source 
const (
	NaslParserRULE_program                      = 0
	NaslParserRULE_statementList                = 1
	NaslParserRULE_statement                    = 2
	NaslParserRULE_block                        = 3
	NaslParserRULE_variableDeclarationStatement = 4
	NaslParserRULE_expressionStatement          = 5
	NaslParserRULE_ifStatement                  = 6
	NaslParserRULE_iterationStatement           = 7
	NaslParserRULE_continueStatement            = 8
	NaslParserRULE_breakStatement               = 9
	NaslParserRULE_returnStatement              = 10
	NaslParserRULE_exitStatement                = 11
	NaslParserRULE_argumentList                 = 12
	NaslParserRULE_argument                     = 13
	NaslParserRULE_expressionSequence           = 14
	NaslParserRULE_functionDeclarationStatement = 15
	NaslParserRULE_parameterList                = 16
	NaslParserRULE_arrayLiteral                 = 17
	NaslParserRULE_elementList                  = 18
	NaslParserRULE_arrayElement                 = 19
	NaslParserRULE_singleExpression             = 20
	NaslParserRULE_literal                      = 21
	NaslParserRULE_numericLiteral               = 22
	NaslParserRULE_identifier                   = 23
	NaslParserRULE_assignmentOperator           = 24
	NaslParserRULE_eos                          = 25
)

NaslParser rules.

Variables

This section is empty.

Functions

func NaslLexerInit 

func NaslLexerInit()

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

func NaslParserInit 

func NaslParserInit()

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

Types

type AdditiveExpressionContext 

type AdditiveExpressionContext struct {
	*SingleExpressionContext
}

func NewAdditiveExpressionContext 

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

func (*AdditiveExpressionContext) Accept 

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

func (*AdditiveExpressionContext) AllSingleExpression 

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

func (*AdditiveExpressionContext) GetRuleContext 

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

func (*AdditiveExpressionContext) Minus 

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

func (*AdditiveExpressionContext) Plus 

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

func (*AdditiveExpressionContext) SingleExpression 

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

type ArgumentContext 

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

func NewArgumentContext 

func NewArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentContext

func NewEmptyArgumentContext 

func NewEmptyArgumentContext() *ArgumentContext

func (*ArgumentContext) Accept 

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

func (*ArgumentContext) Colon 

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

func (*ArgumentContext) GetParser 

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

func (*ArgumentContext) GetRuleContext 

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

func (*ArgumentContext) Identifier 

func (s *ArgumentContext) Identifier() IIdentifierContext

func (*ArgumentContext) IsArgumentContext 

func (*ArgumentContext) IsArgumentContext()

func (*ArgumentContext) SingleExpression 

func (s *ArgumentContext) SingleExpression() ISingleExpressionContext

func (*ArgumentContext) ToStringTree 

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

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

func (s *ArgumentListContext) AllArgument() []IArgumentContext

func (*ArgumentListContext) AllComma 

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

func (*ArgumentListContext) Argument 

func (s *ArgumentListContext) Argument(i int) IArgumentContext

func (*ArgumentListContext) Comma 

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

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 ArrayElementContext 

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

func NewArrayElementContext 

func NewArrayElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementContext

func NewEmptyArrayElementContext 

func NewEmptyArrayElementContext() *ArrayElementContext

func (*ArrayElementContext) Accept 

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

func (*ArrayElementContext) Comma 

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

func (*ArrayElementContext) GetParser 

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

func (*ArrayElementContext) GetRuleContext 

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

func (*ArrayElementContext) Identifier 

func (s *ArrayElementContext) Identifier() IIdentifierContext

func (*ArrayElementContext) IsArrayElementContext 

func (*ArrayElementContext) IsArrayElementContext()

func (*ArrayElementContext) SingleExpression 

func (s *ArrayElementContext) SingleExpression() ISingleExpressionContext

func (*ArrayElementContext) ToStringTree 

func (s *ArrayElementContext) 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) CloseBracket 

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

func (*ArrayLiteralContext) ElementList 

func (s *ArrayLiteralContext) ElementList() IElementListContext

func (*ArrayLiteralContext) GetParser 

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

func (*ArrayLiteralContext) GetRuleContext 

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

func (*ArrayLiteralContext) IsArrayLiteralContext 

func (*ArrayLiteralContext) IsArrayLiteralContext()

func (*ArrayLiteralContext) OpenBracket 

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

func (*ArrayLiteralContext) ToStringTree 

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

type ArrayLiteralExpressionContext 

type ArrayLiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewArrayLiteralExpressionContext 

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

func (*ArrayLiteralExpressionContext) Accept 

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

func (*ArrayLiteralExpressionContext) ArrayLiteral 

func (s *ArrayLiteralExpressionContext) ArrayLiteral() IArrayLiteralContext

func (*ArrayLiteralExpressionContext) GetRuleContext 

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

type AssignmentExpressionContext 

type AssignmentExpressionContext struct {
	*SingleExpressionContext
}

func NewAssignmentExpressionContext 

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

func (*AssignmentExpressionContext) Accept 

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

func (*AssignmentExpressionContext) AllIdentifier added in v1.2.2 

func (s *AssignmentExpressionContext) AllIdentifier() []IIdentifierContext

func (*AssignmentExpressionContext) AllSingleExpression 

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

func (*AssignmentExpressionContext) AssignmentOperator 

func (s *AssignmentExpressionContext) AssignmentOperator() IAssignmentOperatorContext

func (*AssignmentExpressionContext) CloseBracket 

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

func (*AssignmentExpressionContext) Dot 

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

func (*AssignmentExpressionContext) GetRuleContext 

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

func (*AssignmentExpressionContext) Identifier 

func (s *AssignmentExpressionContext) Identifier(i int) IIdentifierContext

func (*AssignmentExpressionContext) OpenBracket 

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

func (*AssignmentExpressionContext) SingleExpression 

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

type AssignmentOperatorContext 

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

func NewAssignmentOperatorContext 

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

func NewEmptyAssignmentOperatorContext 

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext

func (*AssignmentOperatorContext) Accept 

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

func (*AssignmentOperatorContext) Assign 

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

func (*AssignmentOperatorContext) DivideAssign 

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

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

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

func (*AssignmentOperatorContext) ModulusAssign 

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

func (*AssignmentOperatorContext) MultiplyAssign 

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

func (*AssignmentOperatorContext) PlusAssign 

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

func (*AssignmentOperatorContext) ToStringTree 

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

type BaseNaslParserVisitor 

type BaseNaslParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseNaslParserVisitor) VisitAdditiveExpression 

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

func (*BaseNaslParserVisitor) VisitArgument 

func (v *BaseNaslParserVisitor) VisitArgument(ctx *ArgumentContext) interface{}

func (*BaseNaslParserVisitor) VisitArgumentList 

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

func (*BaseNaslParserVisitor) VisitArrayElement 

func (v *BaseNaslParserVisitor) VisitArrayElement(ctx *ArrayElementContext) interface{}

func (*BaseNaslParserVisitor) VisitArrayLiteral 

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

func (*BaseNaslParserVisitor) VisitArrayLiteralExpression 

func (v *BaseNaslParserVisitor) VisitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitAssignmentExpression 

func (v *BaseNaslParserVisitor) VisitAssignmentExpression(ctx *AssignmentExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitAssignmentOperator 

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

func (*BaseNaslParserVisitor) VisitBitAndExpression 

func (v *BaseNaslParserVisitor) VisitBitAndExpression(ctx *BitAndExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitBitNotExpression 

func (v *BaseNaslParserVisitor) VisitBitNotExpression(ctx *BitNotExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitBitOrExpression 

func (v *BaseNaslParserVisitor) VisitBitOrExpression(ctx *BitOrExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitBitShiftExpression 

func (v *BaseNaslParserVisitor) VisitBitShiftExpression(ctx *BitShiftExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitBitXOrExpression 

func (v *BaseNaslParserVisitor) VisitBitXOrExpression(ctx *BitXOrExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitBlock 

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

func (*BaseNaslParserVisitor) VisitBreakStatement 

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

func (*BaseNaslParserVisitor) VisitCallExpression 

func (v *BaseNaslParserVisitor) VisitCallExpression(ctx *CallExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitContinueStatement 

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

func (*BaseNaslParserVisitor) VisitElementList 

func (v *BaseNaslParserVisitor) VisitElementList(ctx *ElementListContext) interface{}

func (*BaseNaslParserVisitor) VisitEos 

func (v *BaseNaslParserVisitor) VisitEos(ctx *EosContext) interface{}

func (*BaseNaslParserVisitor) VisitEqualityExpression 

func (v *BaseNaslParserVisitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitExitStatement 

func (v *BaseNaslParserVisitor) VisitExitStatement(ctx *ExitStatementContext) interface{}

func (*BaseNaslParserVisitor) VisitExpressionSequence 

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

func (*BaseNaslParserVisitor) VisitExpressionStatement 

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

func (*BaseNaslParserVisitor) VisitForEach 

func (v *BaseNaslParserVisitor) VisitForEach(ctx *ForEachContext) interface{}

func (*BaseNaslParserVisitor) VisitFunctionDeclarationStatement 

func (v *BaseNaslParserVisitor) VisitFunctionDeclarationStatement(ctx *FunctionDeclarationStatementContext) interface{}

func (*BaseNaslParserVisitor) VisitIdentifier 

func (v *BaseNaslParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}

func (*BaseNaslParserVisitor) VisitIdentifierExpression 

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

func (*BaseNaslParserVisitor) VisitIfStatement 

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

func (*BaseNaslParserVisitor) VisitLiteral 

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

func (*BaseNaslParserVisitor) VisitLiteralExpression 

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

func (*BaseNaslParserVisitor) VisitLogicalAndExpression 

func (v *BaseNaslParserVisitor) VisitLogicalAndExpression(ctx *LogicalAndExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitLogicalOrExpression 

func (v *BaseNaslParserVisitor) VisitLogicalOrExpression(ctx *LogicalOrExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitMemberDotExpression 

func (v *BaseNaslParserVisitor) VisitMemberDotExpression(ctx *MemberDotExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitMemberIndexExpression 

func (v *BaseNaslParserVisitor) VisitMemberIndexExpression(ctx *MemberIndexExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitMultiplicativeExpression 

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

func (*BaseNaslParserVisitor) VisitNotExpression 

func (v *BaseNaslParserVisitor) VisitNotExpression(ctx *NotExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitNumericLiteral 

func (v *BaseNaslParserVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{}

func (*BaseNaslParserVisitor) VisitParameterList 

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

func (*BaseNaslParserVisitor) VisitParenthesizedExpression 

func (v *BaseNaslParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitPostDecreaseExpression 

func (v *BaseNaslParserVisitor) VisitPostDecreaseExpression(ctx *PostDecreaseExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitPostIncrementExpression 

func (v *BaseNaslParserVisitor) VisitPostIncrementExpression(ctx *PostIncrementExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitPreDecreaseExpression 

func (v *BaseNaslParserVisitor) VisitPreDecreaseExpression(ctx *PreDecreaseExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitPreIncrementExpression 

func (v *BaseNaslParserVisitor) VisitPreIncrementExpression(ctx *PreIncrementExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitProgram 

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

func (*BaseNaslParserVisitor) VisitRelationalExpression 

func (v *BaseNaslParserVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitRepeat 

func (v *BaseNaslParserVisitor) VisitRepeat(ctx *RepeatContext) interface{}

func (*BaseNaslParserVisitor) VisitReturnStatement 

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

func (*BaseNaslParserVisitor) VisitStatement 

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

func (*BaseNaslParserVisitor) VisitStatementList 

func (v *BaseNaslParserVisitor) VisitStatementList(ctx *StatementListContext) interface{}

func (*BaseNaslParserVisitor) VisitTraditionalFor 

func (v *BaseNaslParserVisitor) VisitTraditionalFor(ctx *TraditionalForContext) interface{}

func (*BaseNaslParserVisitor) VisitUnaryMinusExpression 

func (v *BaseNaslParserVisitor) VisitUnaryMinusExpression(ctx *UnaryMinusExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitUnaryPlusExpression 

func (v *BaseNaslParserVisitor) VisitUnaryPlusExpression(ctx *UnaryPlusExpressionContext) interface{}

func (*BaseNaslParserVisitor) VisitVariableDeclarationStatement 

func (v *BaseNaslParserVisitor) VisitVariableDeclarationStatement(ctx *VariableDeclarationStatementContext) interface{}

func (*BaseNaslParserVisitor) VisitWhile 

func (v *BaseNaslParserVisitor) VisitWhile(ctx *WhileContext) interface{}

func (*BaseNaslParserVisitor) VisitXExpression 

func (v *BaseNaslParserVisitor) VisitXExpression(ctx *XExpressionContext) interface{}

type BitAndExpressionContext 

type BitAndExpressionContext struct {
	*SingleExpressionContext
}

func NewBitAndExpressionContext 

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

func (*BitAndExpressionContext) Accept 

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

func (*BitAndExpressionContext) AllSingleExpression 

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

func (*BitAndExpressionContext) BitAnd 

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

func (*BitAndExpressionContext) GetRuleContext 

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

func (*BitAndExpressionContext) SingleExpression 

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

type BitNotExpressionContext 

type BitNotExpressionContext struct {
	*SingleExpressionContext
}

func NewBitNotExpressionContext 

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

func (*BitNotExpressionContext) Accept 

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

func (*BitNotExpressionContext) BitNot 

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

func (*BitNotExpressionContext) GetRuleContext 

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

func (*BitNotExpressionContext) SingleExpression 

func (s *BitNotExpressionContext) SingleExpression() ISingleExpressionContext

type BitOrExpressionContext 

type BitOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitOrExpressionContext 

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

func (*BitOrExpressionContext) Accept 

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

func (*BitOrExpressionContext) AllSingleExpression 

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

func (*BitOrExpressionContext) BitOr 

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

func (*BitOrExpressionContext) GetRuleContext 

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

func (*BitOrExpressionContext) SingleExpression 

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

type BitShiftExpressionContext 

type BitShiftExpressionContext struct {
	*SingleExpressionContext
}

func NewBitShiftExpressionContext 

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

func (*BitShiftExpressionContext) Accept 

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

func (*BitShiftExpressionContext) AllSingleExpression 

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

func (*BitShiftExpressionContext) GetRuleContext 

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

func (*BitShiftExpressionContext) LeftShiftArithmetic 

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

func (*BitShiftExpressionContext) RightShiftArithmetic 

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

func (*BitShiftExpressionContext) RightShiftArithmeticAssign added in v1.2.2 

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

func (*BitShiftExpressionContext) RightShiftLogical 

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

func (*BitShiftExpressionContext) RightShiftLogicalAssign added in v1.2.2 

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

func (*BitShiftExpressionContext) SingleExpression 

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

type BitXOrExpressionContext 

type BitXOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitXOrExpressionContext 

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

func (*BitXOrExpressionContext) Accept 

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

func (*BitXOrExpressionContext) AllSingleExpression 

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

func (*BitXOrExpressionContext) BitXOr 

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

func (*BitXOrExpressionContext) GetRuleContext 

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

func (*BitXOrExpressionContext) SingleExpression 

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

type BlockContext 

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

func NewBlockContext 

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

func NewEmptyBlockContext 

func NewEmptyBlockContext() *BlockContext

func (*BlockContext) Accept 

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

func (*BlockContext) CloseBrace 

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

func (*BlockContext) Eos 

func (s *BlockContext) Eos() IEosContext

func (*BlockContext) GetParser 

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

func (*BlockContext) GetRuleContext 

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

func (*BlockContext) IsBlockContext 

func (*BlockContext) IsBlockContext()

func (*BlockContext) OpenBrace 

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

func (*BlockContext) StatementList 

func (s *BlockContext) StatementList() IStatementListContext

func (*BlockContext) ToStringTree 

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

type BreakStatementContext 

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

func NewBreakStatementContext 

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

func NewEmptyBreakStatementContext 

func NewEmptyBreakStatementContext() *BreakStatementContext

func (*BreakStatementContext) Accept 

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

func (*BreakStatementContext) Break 

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

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

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

type CallExpressionContext 

type CallExpressionContext struct {
	*SingleExpressionContext
}

func NewCallExpressionContext 

func NewCallExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CallExpressionContext

func (*CallExpressionContext) Accept 

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

func (*CallExpressionContext) ArgumentList 

func (s *CallExpressionContext) ArgumentList() IArgumentListContext

func (*CallExpressionContext) CloseParen 

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

func (*CallExpressionContext) GetRuleContext 

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

func (*CallExpressionContext) OpenParen 

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

func (*CallExpressionContext) SingleExpression 

func (s *CallExpressionContext) SingleExpression() ISingleExpressionContext

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

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

func (*ContinueStatementContext) GetRuleContext 

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

func (*ContinueStatementContext) IsContinueStatementContext 

func (*ContinueStatementContext) IsContinueStatementContext()

func (*ContinueStatementContext) ToStringTree 

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

type ElementListContext 

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

func NewElementListContext 

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

func NewEmptyElementListContext 

func NewEmptyElementListContext() *ElementListContext

func (*ElementListContext) Accept 

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

func (*ElementListContext) AllArrayElement 

func (s *ElementListContext) AllArrayElement() []IArrayElementContext

func (*ElementListContext) AllComma 

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

func (*ElementListContext) ArrayElement 

func (s *ElementListContext) ArrayElement(i int) IArrayElementContext

func (*ElementListContext) Comma 

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

func (*ElementListContext) GetParser 

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

func (*ElementListContext) GetRuleContext 

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

func (*ElementListContext) IsElementListContext 

func (*ElementListContext) IsElementListContext()

func (*ElementListContext) ToStringTree 

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

type EosContext 

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

func NewEmptyEosContext 

func NewEmptyEosContext() *EosContext

func NewEosContext 

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

func (*EosContext) Accept 

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

func (*EosContext) AllSemiColon 

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

func (*EosContext) GetParser 

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

func (*EosContext) GetRuleContext 

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

func (*EosContext) IsEosContext 

func (*EosContext) IsEosContext()

func (*EosContext) SemiColon 

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

func (*EosContext) ToStringTree 

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

type EqualityExpressionContext 

type EqualityExpressionContext struct {
	*SingleExpressionContext
}

func NewEqualityExpressionContext 

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

func (*EqualityExpressionContext) Accept 

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

func (*EqualityExpressionContext) AllSingleExpression 

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

func (*EqualityExpressionContext) EqualsRe 

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

func (*EqualityExpressionContext) Equals_ 

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

func (*EqualityExpressionContext) GetRuleContext 

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

func (*EqualityExpressionContext) MTLT 

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

func (*EqualityExpressionContext) MTNotLT 

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

func (*EqualityExpressionContext) NotEquals 

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

func (*EqualityExpressionContext) NotLong 

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

func (*EqualityExpressionContext) SingleExpression 

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

type ExitStatementContext 

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

func NewEmptyExitStatementContext 

func NewEmptyExitStatementContext() *ExitStatementContext

func NewExitStatementContext 

func NewExitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExitStatementContext

func (*ExitStatementContext) Accept 

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

func (*ExitStatementContext) CloseParen 

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

func (*ExitStatementContext) Exit 

func (s *ExitStatementContext) Exit() antlr.TerminalNode

func (*ExitStatementContext) GetParser 

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

func (*ExitStatementContext) GetRuleContext 

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

func (*ExitStatementContext) IsExitStatementContext 

func (*ExitStatementContext) IsExitStatementContext()

func (*ExitStatementContext) OpenParen 

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

func (*ExitStatementContext) SingleExpression 

func (s *ExitStatementContext) SingleExpression() ISingleExpressionContext

func (*ExitStatementContext) ToStringTree 

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

type ExpressionSequenceContext 

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

func NewEmptyExpressionSequenceContext 

func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext

func NewExpressionSequenceContext 

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

func (*ExpressionSequenceContext) Accept 

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

func (*ExpressionSequenceContext) AllComma 

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

func (*ExpressionSequenceContext) AllSingleExpression 

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

func (*ExpressionSequenceContext) Comma 

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

func (*ExpressionSequenceContext) GetParser 

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

func (*ExpressionSequenceContext) GetRuleContext 

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

func (*ExpressionSequenceContext) IsExpressionSequenceContext 

func (*ExpressionSequenceContext) IsExpressionSequenceContext()

func (*ExpressionSequenceContext) SingleExpression 

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

func (*ExpressionSequenceContext) ToStringTree 

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

type ExpressionStatementContext 

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

func NewEmptyExpressionStatementContext 

func NewEmptyExpressionStatementContext() *ExpressionStatementContext

func NewExpressionStatementContext 

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

func (*ExpressionStatementContext) Accept 

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

func (*ExpressionStatementContext) ExpressionSequence 

func (s *ExpressionStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ExpressionStatementContext) GetParser 

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

func (*ExpressionStatementContext) GetRuleContext 

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

func (*ExpressionStatementContext) IsExpressionStatementContext 

func (*ExpressionStatementContext) IsExpressionStatementContext()

func (*ExpressionStatementContext) ToStringTree 

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

type ForEachContext 

type ForEachContext struct {
	*IterationStatementContext
}

func NewForEachContext 

func NewForEachContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForEachContext

func (*ForEachContext) Accept 

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

func (*ForEachContext) CloseParen 

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

func (*ForEachContext) ForEach 

func (s *ForEachContext) ForEach() antlr.TerminalNode

func (*ForEachContext) GetRuleContext 

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

func (*ForEachContext) Identifier 

func (s *ForEachContext) Identifier() IIdentifierContext

func (*ForEachContext) OpenParen 

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

func (*ForEachContext) SingleExpression 

func (s *ForEachContext) SingleExpression() ISingleExpressionContext

func (*ForEachContext) Statement 

func (s *ForEachContext) Statement() IStatementContext

type FunctionDeclarationStatementContext 

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

func NewEmptyFunctionDeclarationStatementContext 

func NewEmptyFunctionDeclarationStatementContext() *FunctionDeclarationStatementContext

func NewFunctionDeclarationStatementContext 

func NewFunctionDeclarationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationStatementContext

func (*FunctionDeclarationStatementContext) Accept 

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

func (*FunctionDeclarationStatementContext) Block 

func (s *FunctionDeclarationStatementContext) Block() IBlockContext

func (*FunctionDeclarationStatementContext) CloseParen 

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

func (*FunctionDeclarationStatementContext) Function_ 

func (s *FunctionDeclarationStatementContext) Function_() antlr.TerminalNode

func (*FunctionDeclarationStatementContext) GetParser 

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

func (*FunctionDeclarationStatementContext) GetRuleContext 

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

func (*FunctionDeclarationStatementContext) Identifier 

func (s *FunctionDeclarationStatementContext) Identifier() IIdentifierContext

func (*FunctionDeclarationStatementContext) IsFunctionDeclarationStatementContext 

func (*FunctionDeclarationStatementContext) IsFunctionDeclarationStatementContext()

func (*FunctionDeclarationStatementContext) OpenParen 

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

func (*FunctionDeclarationStatementContext) ParameterList 

func (s *FunctionDeclarationStatementContext) ParameterList() IParameterListContext

func (*FunctionDeclarationStatementContext) ToStringTree 

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

type IArgumentContext 

type IArgumentContext interface {
	antlr.ParserRuleContext

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

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

IArgumentContext is an interface to support dynamic dispatch.

type IArgumentListContext 

type IArgumentListContext interface {
	antlr.ParserRuleContext

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

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

IArgumentListContext is an interface to support dynamic dispatch.

type IArrayElementContext 

type IArrayElementContext interface {
	antlr.ParserRuleContext

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

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

IArrayElementContext is an interface to support dynamic dispatch.

type IArrayLiteralContext 

type IArrayLiteralContext interface {
	antlr.ParserRuleContext

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

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

IArrayLiteralContext is an interface to support dynamic dispatch.

type IAssignmentOperatorContext 

type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

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

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

IAssignmentOperatorContext is an interface to support dynamic dispatch.

type IBlockContext 

type IBlockContext interface {
	antlr.ParserRuleContext

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

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

IBlockContext is an interface to support dynamic dispatch.

type IBreakStatementContext 

type IBreakStatementContext interface {
	antlr.ParserRuleContext

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

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

IBreakStatementContext is an interface to support dynamic dispatch.

type IContinueStatementContext 

type IContinueStatementContext interface {
	antlr.ParserRuleContext

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

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

IContinueStatementContext is an interface to support dynamic dispatch.

type IElementListContext 

type IElementListContext interface {
	antlr.ParserRuleContext

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

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

IElementListContext is an interface to support dynamic dispatch.

type IEosContext 

type IEosContext interface {
	antlr.ParserRuleContext

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

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

IEosContext is an interface to support dynamic dispatch.

type IExitStatementContext 

type IExitStatementContext interface {
	antlr.ParserRuleContext

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

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

IExitStatementContext is an interface to support dynamic dispatch.

type IExpressionSequenceContext 

type IExpressionSequenceContext interface {
	antlr.ParserRuleContext

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

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

IExpressionSequenceContext is an interface to support dynamic dispatch.

type IExpressionStatementContext 

type IExpressionStatementContext interface {
	antlr.ParserRuleContext

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

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

IExpressionStatementContext is an interface to support dynamic dispatch.

type IFunctionDeclarationStatementContext 

type IFunctionDeclarationStatementContext interface {
	antlr.ParserRuleContext

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

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

IFunctionDeclarationStatementContext is an interface to support dynamic dispatch.

type IIdentifierContext 

type IIdentifierContext interface {
	antlr.ParserRuleContext

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

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

IIdentifierContext is an interface to support dynamic dispatch.

type IIfStatementContext 

type IIfStatementContext interface {
	antlr.ParserRuleContext

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

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

IIfStatementContext is an interface to support dynamic dispatch.

type IIterationStatementContext 

type IIterationStatementContext interface {
	antlr.ParserRuleContext

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

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

IIterationStatementContext is an interface to support dynamic dispatch.

type ILiteralContext 

type ILiteralContext interface {
	antlr.ParserRuleContext

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

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

ILiteralContext is an interface to support dynamic dispatch.

type INumericLiteralContext 

type INumericLiteralContext interface {
	antlr.ParserRuleContext

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

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

INumericLiteralContext is an interface to support dynamic dispatch.

type IParameterListContext 

type IParameterListContext interface {
	antlr.ParserRuleContext

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

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

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

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

IReturnStatementContext is an interface to support dynamic dispatch.

type ISingleExpressionContext 

type ISingleExpressionContext interface {
	antlr.ParserRuleContext

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

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

ISingleExpressionContext is an interface to support dynamic dispatch.

type IStatementContext 

type IStatementContext interface {
	antlr.ParserRuleContext

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

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

IStatementContext is an interface to support dynamic dispatch.

type IStatementListContext 

type IStatementListContext interface {
	antlr.ParserRuleContext

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

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

IStatementListContext is an interface to support dynamic dispatch.

type IVariableDeclarationStatementContext 

type IVariableDeclarationStatementContext interface {
	antlr.ParserRuleContext

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

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

IVariableDeclarationStatementContext is an interface to support dynamic dispatch.

type IdentifierContext 

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

func NewEmptyIdentifierContext 

func NewEmptyIdentifierContext() *IdentifierContext

func NewIdentifierContext 

func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext

func (*IdentifierContext) Accept 

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

func (*IdentifierContext) GetParser 

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

func (*IdentifierContext) GetRuleContext 

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

func (*IdentifierContext) Identifier 

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

func (*IdentifierContext) IsIdentifierContext 

func (*IdentifierContext) IsIdentifierContext()

func (*IdentifierContext) ToStringTree 

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

func (*IdentifierContext) X 

func (s *IdentifierContext) X() antlr.TerminalNode

type IdentifierExpressionContext 

type IdentifierExpressionContext struct {
	*SingleExpressionContext
}

func NewIdentifierExpressionContext 

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

func (*IdentifierExpressionContext) Accept 

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

func (*IdentifierExpressionContext) GetRuleContext 

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

func (*IdentifierExpressionContext) Identifier 

func (s *IdentifierExpressionContext) Identifier() IIdentifierContext

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

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

func (*IfStatementContext) AllStatement 

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

func (*IfStatementContext) CloseParen 

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

func (*IfStatementContext) Else 

func (s *IfStatementContext) Else() antlr.TerminalNode

func (*IfStatementContext) Eos 

func (s *IfStatementContext) Eos() IEosContext

func (*IfStatementContext) GetParser 

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

func (*IfStatementContext) GetRuleContext 

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

func (*IfStatementContext) If 

func (s *IfStatementContext) If() antlr.TerminalNode

func (*IfStatementContext) IsIfStatementContext 

func (*IfStatementContext) IsIfStatementContext()

func (*IfStatementContext) OpenParen 

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

func (*IfStatementContext) SingleExpression 

func (s *IfStatementContext) SingleExpression() ISingleExpressionContext

func (*IfStatementContext) Statement 

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

func (*IfStatementContext) ToStringTree 

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

type IterationStatementContext 

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

func NewEmptyIterationStatementContext 

func NewEmptyIterationStatementContext() *IterationStatementContext

func NewIterationStatementContext 

func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext

func (*IterationStatementContext) CopyFrom 

func (s *IterationStatementContext) CopyFrom(ctx *IterationStatementContext)

func (*IterationStatementContext) GetParser 

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

func (*IterationStatementContext) GetRuleContext 

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

func (*IterationStatementContext) IsIterationStatementContext 

func (*IterationStatementContext) IsIterationStatementContext()

func (*IterationStatementContext) ToStringTree 

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

type 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) BooleanLiteral 

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

func (*LiteralContext) GetParser 

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

func (*LiteralContext) GetRuleContext 

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

func (*LiteralContext) IpLiteral 

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

func (*LiteralContext) IsLiteralContext 

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) NULLLiteral 

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

func (*LiteralContext) NumericLiteral 

func (s *LiteralContext) NumericLiteral() INumericLiteralContext

func (*LiteralContext) StringLiteral 

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

func (*LiteralContext) ToStringTree 

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

type LiteralExpressionContext 

type LiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewLiteralExpressionContext 

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

func (*LiteralExpressionContext) Accept 

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

func (*LiteralExpressionContext) GetRuleContext 

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

func (*LiteralExpressionContext) Literal 

func (s *LiteralExpressionContext) Literal() ILiteralContext

type LogicalAndExpressionContext 

type LogicalAndExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalAndExpressionContext 

func NewLogicalAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndExpressionContext

func (*LogicalAndExpressionContext) Accept 

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

func (*LogicalAndExpressionContext) AllSingleExpression 

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

func (*LogicalAndExpressionContext) And 

func (s *LogicalAndExpressionContext) And() antlr.TerminalNode

func (*LogicalAndExpressionContext) GetRuleContext 

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

func (*LogicalAndExpressionContext) SingleExpression 

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

type LogicalOrExpressionContext 

type LogicalOrExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalOrExpressionContext 

func NewLogicalOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrExpressionContext

func (*LogicalOrExpressionContext) Accept 

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

func (*LogicalOrExpressionContext) AllSingleExpression 

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

func (*LogicalOrExpressionContext) GetRuleContext 

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

func (*LogicalOrExpressionContext) Or 

func (s *LogicalOrExpressionContext) Or() antlr.TerminalNode

func (*LogicalOrExpressionContext) SingleExpression 

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

type MemberDotExpressionContext 

type MemberDotExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberDotExpressionContext 

func NewMemberDotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberDotExpressionContext

func (*MemberDotExpressionContext) Accept 

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

func (*MemberDotExpressionContext) Dot 

func (s *MemberDotExpressionContext) Dot() antlr.TerminalNode

func (*MemberDotExpressionContext) GetRuleContext 

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

func (*MemberDotExpressionContext) Identifier 

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

func (*MemberDotExpressionContext) SingleExpression 

func (s *MemberDotExpressionContext) SingleExpression() ISingleExpressionContext

type MemberIndexExpressionContext 

type MemberIndexExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberIndexExpressionContext 

func NewMemberIndexExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberIndexExpressionContext

func (*MemberIndexExpressionContext) Accept 

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

func (*MemberIndexExpressionContext) AllSingleExpression 

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

func (*MemberIndexExpressionContext) CloseBracket 

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

func (*MemberIndexExpressionContext) GetRuleContext 

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

func (*MemberIndexExpressionContext) OpenBracket 

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

func (*MemberIndexExpressionContext) SingleExpression 

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

type MultiplicativeExpressionContext 

type MultiplicativeExpressionContext struct {
	*SingleExpressionContext
}

func NewMultiplicativeExpressionContext 

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

func (*MultiplicativeExpressionContext) Accept 

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

func (*MultiplicativeExpressionContext) AllSingleExpression 

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

func (*MultiplicativeExpressionContext) Divide 

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

func (*MultiplicativeExpressionContext) GetRuleContext 

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

func (*MultiplicativeExpressionContext) Modulus 

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

func (*MultiplicativeExpressionContext) Multiply 

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

func (*MultiplicativeExpressionContext) Pow 

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

func (*MultiplicativeExpressionContext) SingleExpression 

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

type NaslLexer 

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

func NewNaslLexer 

func NewNaslLexer(input antlr.CharStream) *NaslLexer

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

type NaslParser 

type NaslParser struct {
	*antlr.BaseParser
}

func NewNaslParser 

func NewNaslParser(input antlr.TokenStream) *NaslParser

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

func (*NaslParser) Argument 

func (p *NaslParser) Argument() (localctx IArgumentContext)

func (*NaslParser) ArgumentList 

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

func (*NaslParser) ArrayElement 

func (p *NaslParser) ArrayElement() (localctx IArrayElementContext)

func (*NaslParser) ArrayLiteral 

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

func (*NaslParser) AssignmentOperator 

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

func (*NaslParser) Block 

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

func (*NaslParser) BreakStatement 

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

func (*NaslParser) ContinueStatement 

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

func (*NaslParser) ElementList 

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

func (*NaslParser) Eos 

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

func (*NaslParser) ExitStatement 

func (p *NaslParser) ExitStatement() (localctx IExitStatementContext)

func (*NaslParser) ExpressionSequence 

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

func (*NaslParser) ExpressionStatement 

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

func (*NaslParser) FunctionDeclarationStatement 

func (p *NaslParser) FunctionDeclarationStatement() (localctx IFunctionDeclarationStatementContext)

func (*NaslParser) Identifier 

func (p *NaslParser) Identifier() (localctx IIdentifierContext)

func (*NaslParser) IfStatement 

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

func (*NaslParser) IterationStatement 

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

func (*NaslParser) Literal 

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

func (*NaslParser) NumericLiteral 

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

func (*NaslParser) ParameterList 

func (p *NaslParser) ParameterList() (localctx IParameterListContext)

func (*NaslParser) Program 

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

func (*NaslParser) ReturnStatement 

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

func (*NaslParser) Sempred 

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

func (*NaslParser) SingleExpression 

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

func (*NaslParser) SingleExpression_Sempred 

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

func (*NaslParser) Statement 

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

func (*NaslParser) StatementList 

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

func (*NaslParser) VariableDeclarationStatement 

func (p *NaslParser) VariableDeclarationStatement() (localctx IVariableDeclarationStatementContext)

type NaslParserVisitor 

type NaslParserVisitor interface {
	antlr.ParseTreeVisitor

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

	// Visit a parse tree produced by NaslParser#statementList.
	VisitStatementList(ctx *StatementListContext) interface{}

	// Visit a parse tree produced by NaslParser#statement.
	VisitStatement(ctx *StatementContext) interface{}

	// Visit a parse tree produced by NaslParser#block.
	VisitBlock(ctx *BlockContext) interface{}

	// Visit a parse tree produced by NaslParser#variableDeclarationStatement.
	VisitVariableDeclarationStatement(ctx *VariableDeclarationStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#expressionStatement.
	VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#ifStatement.
	VisitIfStatement(ctx *IfStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#TraditionalFor.
	VisitTraditionalFor(ctx *TraditionalForContext) interface{}

	// Visit a parse tree produced by NaslParser#ForEach.
	VisitForEach(ctx *ForEachContext) interface{}

	// Visit a parse tree produced by NaslParser#While.
	VisitWhile(ctx *WhileContext) interface{}

	// Visit a parse tree produced by NaslParser#Repeat.
	VisitRepeat(ctx *RepeatContext) interface{}

	// Visit a parse tree produced by NaslParser#continueStatement.
	VisitContinueStatement(ctx *ContinueStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#breakStatement.
	VisitBreakStatement(ctx *BreakStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#returnStatement.
	VisitReturnStatement(ctx *ReturnStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#exitStatement.
	VisitExitStatement(ctx *ExitStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#argumentList.
	VisitArgumentList(ctx *ArgumentListContext) interface{}

	// Visit a parse tree produced by NaslParser#argument.
	VisitArgument(ctx *ArgumentContext) interface{}

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

	// Visit a parse tree produced by NaslParser#functionDeclarationStatement.
	VisitFunctionDeclarationStatement(ctx *FunctionDeclarationStatementContext) interface{}

	// Visit a parse tree produced by NaslParser#parameterList.
	VisitParameterList(ctx *ParameterListContext) interface{}

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

	// Visit a parse tree produced by NaslParser#elementList.
	VisitElementList(ctx *ElementListContext) interface{}

	// Visit a parse tree produced by NaslParser#arrayElement.
	VisitArrayElement(ctx *ArrayElementContext) interface{}

	// Visit a parse tree produced by NaslParser#LogicalAndExpression.
	VisitLogicalAndExpression(ctx *LogicalAndExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#PreIncrementExpression.
	VisitPreIncrementExpression(ctx *PreIncrementExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#LogicalOrExpression.
	VisitLogicalOrExpression(ctx *LogicalOrExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#NotExpression.
	VisitNotExpression(ctx *NotExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#PreDecreaseExpression.
	VisitPreDecreaseExpression(ctx *PreDecreaseExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#UnaryMinusExpression.
	VisitUnaryMinusExpression(ctx *UnaryMinusExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#AssignmentExpression.
	VisitAssignmentExpression(ctx *AssignmentExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#PostDecreaseExpression.
	VisitPostDecreaseExpression(ctx *PostDecreaseExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#UnaryPlusExpression.
	VisitUnaryPlusExpression(ctx *UnaryPlusExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#EqualityExpression.
	VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#BitXOrExpression.
	VisitBitXOrExpression(ctx *BitXOrExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#MultiplicativeExpression.
	VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#CallExpression.
	VisitCallExpression(ctx *CallExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#BitShiftExpression.
	VisitBitShiftExpression(ctx *BitShiftExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#ParenthesizedExpression.
	VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#AdditiveExpression.
	VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#RelationalExpression.
	VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#PostIncrementExpression.
	VisitPostIncrementExpression(ctx *PostIncrementExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#BitNotExpression.
	VisitBitNotExpression(ctx *BitNotExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#LiteralExpression.
	VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#ArrayLiteralExpression.
	VisitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#MemberDotExpression.
	VisitMemberDotExpression(ctx *MemberDotExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#MemberIndexExpression.
	VisitMemberIndexExpression(ctx *MemberIndexExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#IdentifierExpression.
	VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#BitAndExpression.
	VisitBitAndExpression(ctx *BitAndExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#BitOrExpression.
	VisitBitOrExpression(ctx *BitOrExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#XExpression.
	VisitXExpression(ctx *XExpressionContext) interface{}

	// Visit a parse tree produced by NaslParser#literal.
	VisitLiteral(ctx *LiteralContext) interface{}

	// Visit a parse tree produced by NaslParser#numericLiteral.
	VisitNumericLiteral(ctx *NumericLiteralContext) interface{}

	// Visit a parse tree produced by NaslParser#identifier.
	VisitIdentifier(ctx *IdentifierContext) interface{}

	// Visit a parse tree produced by NaslParser#assignmentOperator.
	VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}

	// Visit a parse tree produced by NaslParser#eos.
	VisitEos(ctx *EosContext) interface{}
}

A complete Visitor for a parse tree produced by NaslParser.

type NotExpressionContext 

type NotExpressionContext struct {
	*SingleExpressionContext
}

func NewNotExpressionContext 

func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext

func (*NotExpressionContext) Accept 

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

func (*NotExpressionContext) GetRuleContext 

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

func (*NotExpressionContext) Not 

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

func (*NotExpressionContext) SingleExpression 

func (s *NotExpressionContext) SingleExpression() ISingleExpressionContext

type NumericLiteralContext 

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

func NewEmptyNumericLiteralContext 

func NewEmptyNumericLiteralContext() *NumericLiteralContext

func NewNumericLiteralContext 

func NewNumericLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericLiteralContext

func (*NumericLiteralContext) Accept 

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

func (*NumericLiteralContext) FloatLiteral 

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

func (*NumericLiteralContext) GetParser 

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

func (*NumericLiteralContext) GetRuleContext 

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

func (*NumericLiteralContext) HexLiteral 

func (s *NumericLiteralContext) HexLiteral() antlr.TerminalNode

func (*NumericLiteralContext) IntegerLiteral 

func (s *NumericLiteralContext) IntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) IsNumericLiteralContext 

func (*NumericLiteralContext) IsNumericLiteralContext()

func (*NumericLiteralContext) ToStringTree 

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

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

func (s *ParameterListContext) AllIdentifier() []IIdentifierContext

func (*ParameterListContext) Comma 

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

func (*ParameterListContext) GetParser 

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

func (*ParameterListContext) GetRuleContext 

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

func (*ParameterListContext) Identifier 

func (s *ParameterListContext) Identifier(i int) IIdentifierContext

func (*ParameterListContext) IsParameterListContext 

func (*ParameterListContext) IsParameterListContext()

func (*ParameterListContext) ToStringTree 

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

type ParenthesizedExpressionContext 

type ParenthesizedExpressionContext struct {
	*SingleExpressionContext
}

func NewParenthesizedExpressionContext 

func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext

func (*ParenthesizedExpressionContext) Accept 

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

func (*ParenthesizedExpressionContext) CloseParen 

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

func (*ParenthesizedExpressionContext) ExpressionSequence 

func (s *ParenthesizedExpressionContext) ExpressionSequence() IExpressionSequenceContext

func (*ParenthesizedExpressionContext) GetRuleContext 

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

func (*ParenthesizedExpressionContext) OpenParen 

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

type PostDecreaseExpressionContext 

type PostDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPostDecreaseExpressionContext 

func NewPostDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostDecreaseExpressionContext

func (*PostDecreaseExpressionContext) Accept 

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

func (*PostDecreaseExpressionContext) GetRuleContext 

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

func (*PostDecreaseExpressionContext) MinusMinus 

func (s *PostDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PostDecreaseExpressionContext) SingleExpression 

func (s *PostDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PostIncrementExpressionContext 

type PostIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPostIncrementExpressionContext 

func NewPostIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostIncrementExpressionContext

func (*PostIncrementExpressionContext) Accept 

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

func (*PostIncrementExpressionContext) GetRuleContext 

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

func (*PostIncrementExpressionContext) PlusPlus 

func (s *PostIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PostIncrementExpressionContext) SingleExpression 

func (s *PostIncrementExpressionContext) SingleExpression() ISingleExpressionContext

type PreDecreaseExpressionContext 

type PreDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPreDecreaseExpressionContext 

func NewPreDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreDecreaseExpressionContext

func (*PreDecreaseExpressionContext) Accept 

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

func (*PreDecreaseExpressionContext) GetRuleContext 

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

func (*PreDecreaseExpressionContext) MinusMinus 

func (s *PreDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PreDecreaseExpressionContext) SingleExpression 

func (s *PreDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PreIncrementExpressionContext 

type PreIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPreIncrementExpressionContext 

func NewPreIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreIncrementExpressionContext

func (*PreIncrementExpressionContext) Accept 

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

func (*PreIncrementExpressionContext) GetRuleContext 

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

func (*PreIncrementExpressionContext) PlusPlus 

func (s *PreIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PreIncrementExpressionContext) SingleExpression 

func (s *PreIncrementExpressionContext) SingleExpression() ISingleExpressionContext

type ProgramContext 

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

func NewEmptyProgramContext 

func NewEmptyProgramContext() *ProgramContext

func NewProgramContext 

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

func (*ProgramContext) Accept 

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

func (*ProgramContext) EOF 

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

func (*ProgramContext) GetParser 

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

func (*ProgramContext) GetRuleContext 

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

func (*ProgramContext) IsProgramContext 

func (*ProgramContext) IsProgramContext()

func (*ProgramContext) StatementList 

func (s *ProgramContext) StatementList() IStatementListContext

func (*ProgramContext) ToStringTree 

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

type RelationalExpressionContext 

type RelationalExpressionContext struct {
	*SingleExpressionContext
}

func NewRelationalExpressionContext 

func NewRelationalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalExpressionContext

func (*RelationalExpressionContext) Accept 

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

func (*RelationalExpressionContext) AllSingleExpression 

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

func (*RelationalExpressionContext) GetRuleContext 

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

func (*RelationalExpressionContext) GreaterThanEquals 

func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) LessThan 

func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode

func (*RelationalExpressionContext) LessThanEquals 

func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) MoreThan 

func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode

func (*RelationalExpressionContext) SingleExpression 

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

type RepeatContext 

type RepeatContext struct {
	*IterationStatementContext
}

func NewRepeatContext 

func NewRepeatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RepeatContext

func (*RepeatContext) Accept 

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

func (*RepeatContext) Eos 

func (s *RepeatContext) Eos() IEosContext

func (*RepeatContext) GetRuleContext 

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

func (*RepeatContext) Repeat 

func (s *RepeatContext) Repeat() antlr.TerminalNode

func (*RepeatContext) SingleExpression 

func (s *RepeatContext) SingleExpression() ISingleExpressionContext

func (*RepeatContext) Statement 

func (s *RepeatContext) Statement() IStatementContext

func (*RepeatContext) Until 

func (s *RepeatContext) Until() antlr.TerminalNode

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

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

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

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

func (*ReturnStatementContext) Return 

func (s *ReturnStatementContext) Return() antlr.TerminalNode

func (*ReturnStatementContext) SingleExpression 

func (s *ReturnStatementContext) SingleExpression() ISingleExpressionContext

func (*ReturnStatementContext) ToStringTree 

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

type SingleExpressionContext 

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

func NewEmptySingleExpressionContext 

func NewEmptySingleExpressionContext() *SingleExpressionContext

func NewSingleExpressionContext 

func NewSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleExpressionContext

func (*SingleExpressionContext) CopyFrom 

func (s *SingleExpressionContext) CopyFrom(ctx *SingleExpressionContext)

func (*SingleExpressionContext) GetParser 

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

func (*SingleExpressionContext) GetRuleContext 

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

func (*SingleExpressionContext) IsSingleExpressionContext 

func (*SingleExpressionContext) IsSingleExpressionContext()

func (*SingleExpressionContext) ToStringTree 

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

type 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) Block 

func (s *StatementContext) Block() IBlockContext

func (*StatementContext) BreakStatement 

func (s *StatementContext) BreakStatement() IBreakStatementContext

func (*StatementContext) ContinueStatement 

func (s *StatementContext) ContinueStatement() IContinueStatementContext

func (*StatementContext) Eos 

func (s *StatementContext) Eos() IEosContext

func (*StatementContext) ExitStatement 

func (s *StatementContext) ExitStatement() IExitStatementContext

func (*StatementContext) ExpressionStatement 

func (s *StatementContext) ExpressionStatement() IExpressionStatementContext

func (*StatementContext) FunctionDeclarationStatement 

func (s *StatementContext) FunctionDeclarationStatement() IFunctionDeclarationStatementContext

func (*StatementContext) GetParser 

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

func (*StatementContext) GetRuleContext 

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

func (*StatementContext) IfStatement 

func (s *StatementContext) IfStatement() IIfStatementContext

func (*StatementContext) IsStatementContext 

func (*StatementContext) IsStatementContext()

func (*StatementContext) IterationStatement 

func (s *StatementContext) IterationStatement() IIterationStatementContext

func (*StatementContext) ReturnStatement 

func (s *StatementContext) ReturnStatement() IReturnStatementContext

func (*StatementContext) ToStringTree 

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

func (*StatementContext) VariableDeclarationStatement 

func (s *StatementContext) VariableDeclarationStatement() IVariableDeclarationStatementContext

type StatementListContext 

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

func NewEmptyStatementListContext 

func NewEmptyStatementListContext() *StatementListContext

func NewStatementListContext 

func NewStatementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementListContext

func (*StatementListContext) Accept 

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

func (*StatementListContext) AllStatement 

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

func (*StatementListContext) GetParser 

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

func (*StatementListContext) GetRuleContext 

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

func (*StatementListContext) IsStatementListContext 

func (*StatementListContext) IsStatementListContext()

func (*StatementListContext) Statement 

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

func (*StatementListContext) ToStringTree 

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

type TraditionalForContext 

type TraditionalForContext struct {
	*IterationStatementContext
}

func NewTraditionalForContext 

func NewTraditionalForContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TraditionalForContext

func (*TraditionalForContext) Accept 

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

func (*TraditionalForContext) AllSemiColon 

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

func (*TraditionalForContext) AllSingleExpression 

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

func (*TraditionalForContext) CloseParen 

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

func (*TraditionalForContext) Eos 

func (s *TraditionalForContext) Eos() IEosContext

func (*TraditionalForContext) For 

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

func (*TraditionalForContext) GetRuleContext 

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

func (*TraditionalForContext) OpenParen 

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

func (*TraditionalForContext) SemiColon 

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

func (*TraditionalForContext) SingleExpression 

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

func (*TraditionalForContext) Statement 

func (s *TraditionalForContext) Statement() IStatementContext

type UnaryMinusExpressionContext 

type UnaryMinusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryMinusExpressionContext 

func NewUnaryMinusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryMinusExpressionContext

func (*UnaryMinusExpressionContext) Accept 

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

func (*UnaryMinusExpressionContext) GetRuleContext 

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

func (*UnaryMinusExpressionContext) Minus 

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

func (*UnaryMinusExpressionContext) SingleExpression 

func (s *UnaryMinusExpressionContext) SingleExpression() ISingleExpressionContext

type UnaryPlusExpressionContext 

type UnaryPlusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryPlusExpressionContext 

func NewUnaryPlusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryPlusExpressionContext

func (*UnaryPlusExpressionContext) Accept 

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

func (*UnaryPlusExpressionContext) GetRuleContext 

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

func (*UnaryPlusExpressionContext) Plus 

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

func (*UnaryPlusExpressionContext) SingleExpression 

func (s *UnaryPlusExpressionContext) SingleExpression() ISingleExpressionContext

type VariableDeclarationStatementContext 

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

func NewEmptyVariableDeclarationStatementContext 

func NewEmptyVariableDeclarationStatementContext() *VariableDeclarationStatementContext

func NewVariableDeclarationStatementContext 

func NewVariableDeclarationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationStatementContext

func (*VariableDeclarationStatementContext) Accept 

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

func (*VariableDeclarationStatementContext) AllComma 

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

func (*VariableDeclarationStatementContext) AllIdentifier 

func (s *VariableDeclarationStatementContext) AllIdentifier() []IIdentifierContext

func (*VariableDeclarationStatementContext) Comma 

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

func (*VariableDeclarationStatementContext) GetParser 

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

func (*VariableDeclarationStatementContext) GetRuleContext 

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

func (*VariableDeclarationStatementContext) GlobalVar 

func (s *VariableDeclarationStatementContext) GlobalVar() antlr.TerminalNode

func (*VariableDeclarationStatementContext) Identifier 

func (s *VariableDeclarationStatementContext) Identifier(i int) IIdentifierContext

func (*VariableDeclarationStatementContext) IsVariableDeclarationStatementContext 

func (*VariableDeclarationStatementContext) IsVariableDeclarationStatementContext()

func (*VariableDeclarationStatementContext) LocalVar 

func (s *VariableDeclarationStatementContext) LocalVar() antlr.TerminalNode

func (*VariableDeclarationStatementContext) ToStringTree 

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

type WhileContext 

type WhileContext struct {
	*IterationStatementContext
}

func NewWhileContext 

func NewWhileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhileContext

func (*WhileContext) Accept 

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

func (*WhileContext) CloseParen 

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

func (*WhileContext) GetRuleContext 

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

func (*WhileContext) OpenParen 

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

func (*WhileContext) SingleExpression 

func (s *WhileContext) SingleExpression() ISingleExpressionContext

func (*WhileContext) Statement 

func (s *WhileContext) Statement() IStatementContext

func (*WhileContext) While 

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

type XExpressionContext 

type XExpressionContext struct {
	*SingleExpressionContext
}

func NewXExpressionContext 

func NewXExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *XExpressionContext

func (*XExpressionContext) Accept 

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

func (*XExpressionContext) AllSingleExpression 

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

func (*XExpressionContext) GetRuleContext 

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

func (*XExpressionContext) SingleExpression 

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

func (*XExpressionContext) X 

func (s *XExpressionContext) X() 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.