parser

package
v0.0.0-...-5e93b50 Latest Latest
Warning

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

 Go to latest Published: Mar 26, 2024 License: MIT Imports: 5 Imported by: 1

README

Download ANTLR4 JAR file

cd /usr/local/lib
curl -O https://www.antlr.org/download/antlr-4.13.1-complete.jar

Setup ANTLR4

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-17.0.1.jdk/Contents/Home
export CLASSPATH=".:/usr/local/lib/antlr-4.13.1-complete.jar:$CLASSPATH"
alias antlr4='java -jar /usr/local/lib/antlr-4.13.1-complete.jar'
alias grun='java org.antlr.v4.gui.TestRig'

Generate Go code

rm -r .antlr
rm *.go *.interp *.tokens
antlr4 -Dlanguage=Go -visitor -package parser *.g4
go mod tidy

Documentation

Index

Constants

View Source 
const (
	GoLexerBREAK                  = 1
	GoLexerDEFAULT                = 2
	GoLexerFUNC                   = 3
	GoLexerINTERFACE              = 4
	GoLexerSELECT                 = 5
	GoLexerCASE                   = 6
	GoLexerDEFER                  = 7
	GoLexerGO                     = 8
	GoLexerMAP                    = 9
	GoLexerSTRUCT                 = 10
	GoLexerCHAN                   = 11
	GoLexerELSE                   = 12
	GoLexerGOTO                   = 13
	GoLexerPACKAGE                = 14
	GoLexerSWITCH                 = 15
	GoLexerCONST                  = 16
	GoLexerFALLTHROUGH            = 17
	GoLexerIF                     = 18
	GoLexerRANGE                  = 19
	GoLexerTYPE                   = 20
	GoLexerCONTINUE               = 21
	GoLexerFOR                    = 22
	GoLexerIMPORT                 = 23
	GoLexerRETURN                 = 24
	GoLexerVAR                    = 25
	GoLexerNIL_LIT                = 26
	GoLexerIDENTIFIER             = 27
	GoLexerL_PAREN                = 28
	GoLexerR_PAREN                = 29
	GoLexerL_CURLY                = 30
	GoLexerR_CURLY                = 31
	GoLexerL_BRACKET              = 32
	GoLexerR_BRACKET              = 33
	GoLexerASSIGN                 = 34
	GoLexerCOMMA                  = 35
	GoLexerSEMI                   = 36
	GoLexerCOLON                  = 37
	GoLexerDOT                    = 38
	GoLexerPLUS_PLUS              = 39
	GoLexerMINUS_MINUS            = 40
	GoLexerDECLARE_ASSIGN         = 41
	GoLexerELLIPSIS               = 42
	GoLexerQuestion               = 43
	GoLexerSafeIndex              = 44
	GoLexerLOGICAL_OR             = 45
	GoLexerLOGICAL_AND            = 46
	GoLexerEQUALS                 = 47
	GoLexerNOT_EQUALS             = 48
	GoLexerLESS                   = 49
	GoLexerLESS_OR_EQUALS         = 50
	GoLexerGREATER                = 51
	GoLexerGREATER_OR_EQUALS      = 52
	GoLexerOR                     = 53
	GoLexerDIV                    = 54
	GoLexerMOD                    = 55
	GoLexerLSHIFT                 = 56
	GoLexerRSHIFT                 = 57
	GoLexerBIT_CLEAR              = 58
	GoLexerUNDERLYING             = 59
	GoLexerEXCLAMATION            = 60
	GoLexerPLUS                   = 61
	GoLexerMINUS                  = 62
	GoLexerCARET                  = 63
	GoLexerSTAR                   = 64
	GoLexerAMPERSAND              = 65
	GoLexerRECEIVE                = 66
	GoLexerDECIMAL_LIT            = 67
	GoLexerBINARY_LIT             = 68
	GoLexerOCTAL_LIT              = 69
	GoLexerHEX_LIT                = 70
	GoLexerFLOAT_LIT              = 71
	GoLexerDECIMAL_FLOAT_LIT      = 72
	GoLexerHEX_FLOAT_LIT          = 73
	GoLexerIMAGINARY_LIT          = 74
	GoLexerBYTE_VALUE             = 75
	GoLexerOCTAL_BYTE_VALUE       = 76
	GoLexerHEX_BYTE_VALUE         = 77
	GoLexerLITTLE_U_VALUE         = 78
	GoLexerBIG_U_VALUE            = 79
	GoLexerRAW_STRING_LIT         = 80
	GoLexerINTERPRETED_STRING_LIT = 81
	GoLexerSINGER_QUOT_STRING_LIT = 82
	GoLexerWS                     = 83
	GoLexerCOMMENT                = 84
	GoLexerTERMINATOR             = 85
	GoLexerLINE_COMMENT           = 86
	GoLexerWS_NLSEMI              = 87
	GoLexerCOMMENT_NLSEMI         = 88
	GoLexerLINE_COMMENT_NLSEMI    = 89
	GoLexerEOS                    = 90
	GoLexerOTHER                  = 91
)

GoLexer tokens.

View Source 
const (
	GoExpressionEOF                    = antlr.TokenEOF
	GoExpressionBREAK                  = 1
	GoExpressionDEFAULT                = 2
	GoExpressionFUNC                   = 3
	GoExpressionINTERFACE              = 4
	GoExpressionSELECT                 = 5
	GoExpressionCASE                   = 6
	GoExpressionDEFER                  = 7
	GoExpressionGO                     = 8
	GoExpressionMAP                    = 9
	GoExpressionSTRUCT                 = 10
	GoExpressionCHAN                   = 11
	GoExpressionELSE                   = 12
	GoExpressionGOTO                   = 13
	GoExpressionPACKAGE                = 14
	GoExpressionSWITCH                 = 15
	GoExpressionCONST                  = 16
	GoExpressionFALLTHROUGH            = 17
	GoExpressionIF                     = 18
	GoExpressionRANGE                  = 19
	GoExpressionTYPE                   = 20
	GoExpressionCONTINUE               = 21
	GoExpressionFOR                    = 22
	GoExpressionIMPORT                 = 23
	GoExpressionRETURN                 = 24
	GoExpressionVAR                    = 25
	GoExpressionNIL_LIT                = 26
	GoExpressionIDENTIFIER             = 27
	GoExpressionL_PAREN                = 28
	GoExpressionR_PAREN                = 29
	GoExpressionL_CURLY                = 30
	GoExpressionR_CURLY                = 31
	GoExpressionL_BRACKET              = 32
	GoExpressionR_BRACKET              = 33
	GoExpressionASSIGN                 = 34
	GoExpressionCOMMA                  = 35
	GoExpressionSEMI                   = 36
	GoExpressionCOLON                  = 37
	GoExpressionDOT                    = 38
	GoExpressionPLUS_PLUS              = 39
	GoExpressionMINUS_MINUS            = 40
	GoExpressionDECLARE_ASSIGN         = 41
	GoExpressionELLIPSIS               = 42
	GoExpressionQuestion               = 43
	GoExpressionSafeIndex              = 44
	GoExpressionLOGICAL_OR             = 45
	GoExpressionLOGICAL_AND            = 46
	GoExpressionEQUALS                 = 47
	GoExpressionNOT_EQUALS             = 48
	GoExpressionLESS                   = 49
	GoExpressionLESS_OR_EQUALS         = 50
	GoExpressionGREATER                = 51
	GoExpressionGREATER_OR_EQUALS      = 52
	GoExpressionOR                     = 53
	GoExpressionDIV                    = 54
	GoExpressionMOD                    = 55
	GoExpressionLSHIFT                 = 56
	GoExpressionRSHIFT                 = 57
	GoExpressionBIT_CLEAR              = 58
	GoExpressionUNDERLYING             = 59
	GoExpressionEXCLAMATION            = 60
	GoExpressionPLUS                   = 61
	GoExpressionMINUS                  = 62
	GoExpressionCARET                  = 63
	GoExpressionSTAR                   = 64
	GoExpressionAMPERSAND              = 65
	GoExpressionRECEIVE                = 66
	GoExpressionDECIMAL_LIT            = 67
	GoExpressionBINARY_LIT             = 68
	GoExpressionOCTAL_LIT              = 69
	GoExpressionHEX_LIT                = 70
	GoExpressionFLOAT_LIT              = 71
	GoExpressionDECIMAL_FLOAT_LIT      = 72
	GoExpressionHEX_FLOAT_LIT          = 73
	GoExpressionIMAGINARY_LIT          = 74
	GoExpressionBYTE_VALUE             = 75
	GoExpressionOCTAL_BYTE_VALUE       = 76
	GoExpressionHEX_BYTE_VALUE         = 77
	GoExpressionLITTLE_U_VALUE         = 78
	GoExpressionBIG_U_VALUE            = 79
	GoExpressionRAW_STRING_LIT         = 80
	GoExpressionINTERPRETED_STRING_LIT = 81
	GoExpressionSINGER_QUOT_STRING_LIT = 82
	GoExpressionWS                     = 83
	GoExpressionCOMMENT                = 84
	GoExpressionTERMINATOR             = 85
	GoExpressionLINE_COMMENT           = 86
	GoExpressionWS_NLSEMI              = 87
	GoExpressionCOMMENT_NLSEMI         = 88
	GoExpressionLINE_COMMENT_NLSEMI    = 89
	GoExpressionEOS                    = 90
	GoExpressionOTHER                  = 91
)

GoExpression tokens.

View Source 
const (
	GoExpressionRULE_expression     = 0
	GoExpressionRULE_primaryExpr    = 1
	GoExpressionRULE_operand        = 2
	GoExpressionRULE_literal        = 3
	GoExpressionRULE_literalNil     = 4
	GoExpressionRULE_integer        = 5
	GoExpressionRULE_string         = 6
	GoExpressionRULE_literalFloat   = 7
	GoExpressionRULE_literalImag    = 8
	GoExpressionRULE_operandName    = 9
	GoExpressionRULE_field          = 10
	GoExpressionRULE_index          = 11
	GoExpressionRULE_slice          = 12
	GoExpressionRULE_arguments      = 13
	GoExpressionRULE_expressionList = 14
)

GoExpression rules.

View Source 
const GoLexerNLSEMI = 1

GoLexerNLSEMI is the GoLexer mode.

Variables

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

Functions

func GoExpressionInit 

func GoExpressionInit()

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

func GoLexerInit 

func GoLexerInit()

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

func InitEmptyArgumentsContext 

func InitEmptyArgumentsContext(p *ArgumentsContext)

func InitEmptyExpressionContext 

func InitEmptyExpressionContext(p *ExpressionContext)

func InitEmptyExpressionListContext 

func InitEmptyExpressionListContext(p *ExpressionListContext)

func InitEmptyFieldContext 

func InitEmptyFieldContext(p *FieldContext)

func InitEmptyIndexContext 

func InitEmptyIndexContext(p *IndexContext)

func InitEmptyIntegerContext 

func InitEmptyIntegerContext(p *IntegerContext)

func InitEmptyLiteralContext 

func InitEmptyLiteralContext(p *LiteralContext)

func InitEmptyLiteralFloatContext 

func InitEmptyLiteralFloatContext(p *LiteralFloatContext)

func InitEmptyLiteralImagContext 

func InitEmptyLiteralImagContext(p *LiteralImagContext)

func InitEmptyLiteralNilContext 

func InitEmptyLiteralNilContext(p *LiteralNilContext)

func InitEmptyOperandContext 

func InitEmptyOperandContext(p *OperandContext)

func InitEmptyOperandNameContext 

func InitEmptyOperandNameContext(p *OperandNameContext)

func InitEmptyPrimaryExprContext 

func InitEmptyPrimaryExprContext(p *PrimaryExprContext)

func InitEmptySliceContext 

func InitEmptySliceContext(p *SliceContext)

func InitEmptyStringContext 

func InitEmptyStringContext(p *StringContext)

Types

type ArgumentsContext 

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

func NewArgumentsContext 

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

func NewEmptyArgumentsContext 

func NewEmptyArgumentsContext() *ArgumentsContext

func (*ArgumentsContext) Accept 

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

func (*ArgumentsContext) COMMA 

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

func (*ArgumentsContext) ELLIPSIS 

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

func (*ArgumentsContext) EnterRule 

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

func (*ArgumentsContext) ExitRule 

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

func (*ArgumentsContext) ExpressionList 

func (s *ArgumentsContext) ExpressionList() IExpressionListContext

func (*ArgumentsContext) GetParser 

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

func (*ArgumentsContext) GetRuleContext 

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

func (*ArgumentsContext) IsArgumentsContext 

func (*ArgumentsContext) IsArgumentsContext()

func (*ArgumentsContext) L_PAREN 

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

func (*ArgumentsContext) R_PAREN 

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

func (*ArgumentsContext) ToStringTree 

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

type BaseGoExpressionListener 

type BaseGoExpressionListener struct{}

BaseGoExpressionListener is a complete listener for a parse tree produced by GoExpression.

func (*BaseGoExpressionListener) EnterArguments 

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

EnterArguments is called when production arguments is entered.

func (*BaseGoExpressionListener) EnterEveryRule 

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

EnterEveryRule is called when any rule is entered.

func (*BaseGoExpressionListener) EnterExpression 

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

EnterExpression is called when production expression is entered.

func (*BaseGoExpressionListener) EnterExpressionList 

func (s *BaseGoExpressionListener) EnterExpressionList(ctx *ExpressionListContext)

EnterExpressionList is called when production expressionList is entered.

func (*BaseGoExpressionListener) EnterField 

func (s *BaseGoExpressionListener) EnterField(ctx *FieldContext)

EnterField is called when production field is entered.

func (*BaseGoExpressionListener) EnterIndex 

func (s *BaseGoExpressionListener) EnterIndex(ctx *IndexContext)

EnterIndex is called when production index is entered.

func (*BaseGoExpressionListener) EnterInteger 

func (s *BaseGoExpressionListener) EnterInteger(ctx *IntegerContext)

EnterInteger is called when production integer is entered.

func (*BaseGoExpressionListener) EnterLiteral 

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

EnterLiteral is called when production literal is entered.

func (*BaseGoExpressionListener) EnterLiteralFloat 

func (s *BaseGoExpressionListener) EnterLiteralFloat(ctx *LiteralFloatContext)

EnterLiteralFloat is called when production literalFloat is entered.

func (*BaseGoExpressionListener) EnterLiteralImag 

func (s *BaseGoExpressionListener) EnterLiteralImag(ctx *LiteralImagContext)

EnterLiteralImag is called when production literalImag is entered.

func (*BaseGoExpressionListener) EnterLiteralNil 

func (s *BaseGoExpressionListener) EnterLiteralNil(ctx *LiteralNilContext)

EnterLiteralNil is called when production literalNil is entered.

func (*BaseGoExpressionListener) EnterOperand 

func (s *BaseGoExpressionListener) EnterOperand(ctx *OperandContext)

EnterOperand is called when production operand is entered.

func (*BaseGoExpressionListener) EnterOperandName 

func (s *BaseGoExpressionListener) EnterOperandName(ctx *OperandNameContext)

EnterOperandName is called when production operandName is entered.

func (*BaseGoExpressionListener) EnterPrimaryExpr 

func (s *BaseGoExpressionListener) EnterPrimaryExpr(ctx *PrimaryExprContext)

EnterPrimaryExpr is called when production primaryExpr is entered.

func (*BaseGoExpressionListener) EnterSlice 

func (s *BaseGoExpressionListener) EnterSlice(ctx *SliceContext)

EnterSlice is called when production slice is entered.

func (*BaseGoExpressionListener) EnterString 

func (s *BaseGoExpressionListener) EnterString(ctx *StringContext)

EnterString is called when production string is entered.

func (*BaseGoExpressionListener) ExitArguments 

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

ExitArguments is called when production arguments is exited.

func (*BaseGoExpressionListener) ExitEveryRule 

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

ExitEveryRule is called when any rule is exited.

func (*BaseGoExpressionListener) ExitExpression 

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

ExitExpression is called when production expression is exited.

func (*BaseGoExpressionListener) ExitExpressionList 

func (s *BaseGoExpressionListener) ExitExpressionList(ctx *ExpressionListContext)

ExitExpressionList is called when production expressionList is exited.

func (*BaseGoExpressionListener) ExitField 

func (s *BaseGoExpressionListener) ExitField(ctx *FieldContext)

ExitField is called when production field is exited.

func (*BaseGoExpressionListener) ExitIndex 

func (s *BaseGoExpressionListener) ExitIndex(ctx *IndexContext)

ExitIndex is called when production index is exited.

func (*BaseGoExpressionListener) ExitInteger 

func (s *BaseGoExpressionListener) ExitInteger(ctx *IntegerContext)

ExitInteger is called when production integer is exited.

func (*BaseGoExpressionListener) ExitLiteral 

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

ExitLiteral is called when production literal is exited.

func (*BaseGoExpressionListener) ExitLiteralFloat 

func (s *BaseGoExpressionListener) ExitLiteralFloat(ctx *LiteralFloatContext)

ExitLiteralFloat is called when production literalFloat is exited.

func (*BaseGoExpressionListener) ExitLiteralImag 

func (s *BaseGoExpressionListener) ExitLiteralImag(ctx *LiteralImagContext)

ExitLiteralImag is called when production literalImag is exited.

func (*BaseGoExpressionListener) ExitLiteralNil 

func (s *BaseGoExpressionListener) ExitLiteralNil(ctx *LiteralNilContext)

ExitLiteralNil is called when production literalNil is exited.

func (*BaseGoExpressionListener) ExitOperand 

func (s *BaseGoExpressionListener) ExitOperand(ctx *OperandContext)

ExitOperand is called when production operand is exited.

func (*BaseGoExpressionListener) ExitOperandName 

func (s *BaseGoExpressionListener) ExitOperandName(ctx *OperandNameContext)

ExitOperandName is called when production operandName is exited.

func (*BaseGoExpressionListener) ExitPrimaryExpr 

func (s *BaseGoExpressionListener) ExitPrimaryExpr(ctx *PrimaryExprContext)

ExitPrimaryExpr is called when production primaryExpr is exited.

func (*BaseGoExpressionListener) ExitSlice 

func (s *BaseGoExpressionListener) ExitSlice(ctx *SliceContext)

ExitSlice is called when production slice is exited.

func (*BaseGoExpressionListener) ExitString 

func (s *BaseGoExpressionListener) ExitString(ctx *StringContext)

ExitString is called when production string is exited.

func (*BaseGoExpressionListener) VisitErrorNode 

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

VisitErrorNode is called when an error node is visited.

func (*BaseGoExpressionListener) VisitTerminal 

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

VisitTerminal is called when a terminal node is visited.

type BaseGoExpressionVisitor 

type BaseGoExpressionVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseGoExpressionVisitor) VisitArguments 

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

func (*BaseGoExpressionVisitor) VisitExpression 

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

func (*BaseGoExpressionVisitor) VisitExpressionList 

func (v *BaseGoExpressionVisitor) VisitExpressionList(ctx *ExpressionListContext) interface{}

func (*BaseGoExpressionVisitor) VisitField 

func (v *BaseGoExpressionVisitor) VisitField(ctx *FieldContext) interface{}

func (*BaseGoExpressionVisitor) VisitIndex 

func (v *BaseGoExpressionVisitor) VisitIndex(ctx *IndexContext) interface{}

func (*BaseGoExpressionVisitor) VisitInteger 

func (v *BaseGoExpressionVisitor) VisitInteger(ctx *IntegerContext) interface{}

func (*BaseGoExpressionVisitor) VisitLiteral 

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

func (*BaseGoExpressionVisitor) VisitLiteralFloat 

func (v *BaseGoExpressionVisitor) VisitLiteralFloat(ctx *LiteralFloatContext) interface{}

func (*BaseGoExpressionVisitor) VisitLiteralImag 

func (v *BaseGoExpressionVisitor) VisitLiteralImag(ctx *LiteralImagContext) interface{}

func (*BaseGoExpressionVisitor) VisitLiteralNil 

func (v *BaseGoExpressionVisitor) VisitLiteralNil(ctx *LiteralNilContext) interface{}

func (*BaseGoExpressionVisitor) VisitOperand 

func (v *BaseGoExpressionVisitor) VisitOperand(ctx *OperandContext) interface{}

func (*BaseGoExpressionVisitor) VisitOperandName 

func (v *BaseGoExpressionVisitor) VisitOperandName(ctx *OperandNameContext) interface{}

func (*BaseGoExpressionVisitor) VisitPrimaryExpr 

func (v *BaseGoExpressionVisitor) VisitPrimaryExpr(ctx *PrimaryExprContext) interface{}

func (*BaseGoExpressionVisitor) VisitSlice 

func (v *BaseGoExpressionVisitor) VisitSlice(ctx *SliceContext) interface{}

func (*BaseGoExpressionVisitor) VisitString 

func (v *BaseGoExpressionVisitor) VisitString(ctx *StringContext) interface{}

type ExpressionContext 

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

func NewEmptyExpressionContext 

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext 

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

func (*ExpressionContext) AMPERSAND 

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

func (*ExpressionContext) Accept 

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

func (*ExpressionContext) AllExpression 

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

func (*ExpressionContext) BIT_CLEAR 

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

func (*ExpressionContext) CARET 

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

func (*ExpressionContext) COLON 

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

func (*ExpressionContext) DIV 

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

func (*ExpressionContext) EQUALS 

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

func (*ExpressionContext) EXCLAMATION 

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

func (*ExpressionContext) EnterRule 

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

func (*ExpressionContext) ExitRule 

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

func (*ExpressionContext) Expression 

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

func (*ExpressionContext) GREATER 

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

func (*ExpressionContext) GREATER_OR_EQUALS 

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

func (*ExpressionContext) GetAdd_op 

func (s *ExpressionContext) GetAdd_op() antlr.Token

func (*ExpressionContext) GetMul_op 

func (s *ExpressionContext) GetMul_op() antlr.Token

func (*ExpressionContext) GetParser 

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

func (*ExpressionContext) GetRel_op 

func (s *ExpressionContext) GetRel_op() antlr.Token

func (*ExpressionContext) GetRuleContext 

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

func (*ExpressionContext) GetUnary_op 

func (s *ExpressionContext) GetUnary_op() antlr.Token

func (*ExpressionContext) IsExpressionContext 

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) LESS 

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

func (*ExpressionContext) LESS_OR_EQUALS 

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

func (*ExpressionContext) LOGICAL_AND 

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

func (*ExpressionContext) LOGICAL_OR 

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

func (*ExpressionContext) LSHIFT 

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

func (*ExpressionContext) MINUS 

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

func (*ExpressionContext) MOD 

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

func (*ExpressionContext) NOT_EQUALS 

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

func (*ExpressionContext) OR 

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

func (*ExpressionContext) PLUS 

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

func (*ExpressionContext) PrimaryExpr 

func (s *ExpressionContext) PrimaryExpr() IPrimaryExprContext

func (*ExpressionContext) Question 

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

func (*ExpressionContext) RECEIVE 

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

func (*ExpressionContext) RSHIFT 

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

func (*ExpressionContext) STAR 

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

func (*ExpressionContext) SetAdd_op 

func (s *ExpressionContext) SetAdd_op(v antlr.Token)

func (*ExpressionContext) SetMul_op 

func (s *ExpressionContext) SetMul_op(v antlr.Token)

func (*ExpressionContext) SetRel_op 

func (s *ExpressionContext) SetRel_op(v antlr.Token)

func (*ExpressionContext) SetUnary_op 

func (s *ExpressionContext) SetUnary_op(v antlr.Token)

func (*ExpressionContext) ToStringTree 

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

type ExpressionListContext 

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

func NewEmptyExpressionListContext 

func NewEmptyExpressionListContext() *ExpressionListContext

func NewExpressionListContext 

func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionListContext

func (*ExpressionListContext) Accept 

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

func (*ExpressionListContext) AllCOMMA 

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

func (*ExpressionListContext) AllExpression 

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

func (*ExpressionListContext) COMMA 

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

func (*ExpressionListContext) EnterRule 

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

func (*ExpressionListContext) ExitRule 

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

func (*ExpressionListContext) Expression 

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

func (*ExpressionListContext) GetParser 

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

func (*ExpressionListContext) GetRuleContext 

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

func (*ExpressionListContext) IsExpressionListContext 

func (*ExpressionListContext) IsExpressionListContext()

func (*ExpressionListContext) ToStringTree 

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

type FieldContext 

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

func NewEmptyFieldContext 

func NewEmptyFieldContext() *FieldContext

func NewFieldContext 

func NewFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldContext

func (*FieldContext) Accept 

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

func (*FieldContext) DOT 

func (s *FieldContext) DOT() antlr.TerminalNode

func (*FieldContext) EnterRule 

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

func (*FieldContext) ExitRule 

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

func (*FieldContext) GetParser 

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

func (*FieldContext) GetRuleContext 

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

func (*FieldContext) IDENTIFIER 

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

func (*FieldContext) IsFieldContext 

func (*FieldContext) IsFieldContext()

func (*FieldContext) SafeIndex 

func (s *FieldContext) SafeIndex() antlr.TerminalNode

func (*FieldContext) ToStringTree 

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

type GoExpression 

type GoExpression struct {
	*antlr.BaseParser
}

func NewGoExpression 

func NewGoExpression(input antlr.TokenStream) *GoExpression

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

func (*GoExpression) Arguments 

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

func (*GoExpression) Expression 

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

func (*GoExpression) ExpressionList 

func (p *GoExpression) ExpressionList() (localctx IExpressionListContext)

func (*GoExpression) Expression_Sempred 

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

func (*GoExpression) Field 

func (p *GoExpression) Field() (localctx IFieldContext)

func (*GoExpression) Index 

func (p *GoExpression) Index() (localctx IIndexContext)

func (*GoExpression) Integer 

func (p *GoExpression) Integer() (localctx IIntegerContext)

func (*GoExpression) Literal 

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

func (*GoExpression) LiteralFloat 

func (p *GoExpression) LiteralFloat() (localctx ILiteralFloatContext)

func (*GoExpression) LiteralImag 

func (p *GoExpression) LiteralImag() (localctx ILiteralImagContext)

func (*GoExpression) LiteralNil 

func (p *GoExpression) LiteralNil() (localctx ILiteralNilContext)

func (*GoExpression) Operand 

func (p *GoExpression) Operand() (localctx IOperandContext)

func (*GoExpression) OperandName 

func (p *GoExpression) OperandName() (localctx IOperandNameContext)

func (*GoExpression) PrimaryExpr 

func (p *GoExpression) PrimaryExpr() (localctx IPrimaryExprContext)

func (*GoExpression) PrimaryExpr_Sempred 

func (p *GoExpression) PrimaryExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*GoExpression) Sempred 

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

func (*GoExpression) Slice 

func (p *GoExpression) Slice() (localctx ISliceContext)

func (*GoExpression) String_ 

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

type GoExpressionListener 

type GoExpressionListener interface {
	antlr.ParseTreeListener

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

	// EnterPrimaryExpr is called when entering the primaryExpr production.
	EnterPrimaryExpr(c *PrimaryExprContext)

	// EnterOperand is called when entering the operand production.
	EnterOperand(c *OperandContext)

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

	// EnterLiteralNil is called when entering the literalNil production.
	EnterLiteralNil(c *LiteralNilContext)

	// EnterInteger is called when entering the integer production.
	EnterInteger(c *IntegerContext)

	// EnterString is called when entering the string production.
	EnterString(c *StringContext)

	// EnterLiteralFloat is called when entering the literalFloat production.
	EnterLiteralFloat(c *LiteralFloatContext)

	// EnterLiteralImag is called when entering the literalImag production.
	EnterLiteralImag(c *LiteralImagContext)

	// EnterOperandName is called when entering the operandName production.
	EnterOperandName(c *OperandNameContext)

	// EnterField is called when entering the field production.
	EnterField(c *FieldContext)

	// EnterIndex is called when entering the index production.
	EnterIndex(c *IndexContext)

	// EnterSlice is called when entering the slice production.
	EnterSlice(c *SliceContext)

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

	// EnterExpressionList is called when entering the expressionList production.
	EnterExpressionList(c *ExpressionListContext)

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

	// ExitPrimaryExpr is called when exiting the primaryExpr production.
	ExitPrimaryExpr(c *PrimaryExprContext)

	// ExitOperand is called when exiting the operand production.
	ExitOperand(c *OperandContext)

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

	// ExitLiteralNil is called when exiting the literalNil production.
	ExitLiteralNil(c *LiteralNilContext)

	// ExitInteger is called when exiting the integer production.
	ExitInteger(c *IntegerContext)

	// ExitString is called when exiting the string production.
	ExitString(c *StringContext)

	// ExitLiteralFloat is called when exiting the literalFloat production.
	ExitLiteralFloat(c *LiteralFloatContext)

	// ExitLiteralImag is called when exiting the literalImag production.
	ExitLiteralImag(c *LiteralImagContext)

	// ExitOperandName is called when exiting the operandName production.
	ExitOperandName(c *OperandNameContext)

	// ExitField is called when exiting the field production.
	ExitField(c *FieldContext)

	// ExitIndex is called when exiting the index production.
	ExitIndex(c *IndexContext)

	// ExitSlice is called when exiting the slice production.
	ExitSlice(c *SliceContext)

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

	// ExitExpressionList is called when exiting the expressionList production.
	ExitExpressionList(c *ExpressionListContext)
}

GoExpressionListener is a complete listener for a parse tree produced by GoExpression.

type GoExpressionVisitor 

type GoExpressionVisitor interface {
	antlr.ParseTreeVisitor

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

	// Visit a parse tree produced by GoExpression#primaryExpr.
	VisitPrimaryExpr(ctx *PrimaryExprContext) interface{}

	// Visit a parse tree produced by GoExpression#operand.
	VisitOperand(ctx *OperandContext) interface{}

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

	// Visit a parse tree produced by GoExpression#literalNil.
	VisitLiteralNil(ctx *LiteralNilContext) interface{}

	// Visit a parse tree produced by GoExpression#integer.
	VisitInteger(ctx *IntegerContext) interface{}

	// Visit a parse tree produced by GoExpression#string.
	VisitString(ctx *StringContext) interface{}

	// Visit a parse tree produced by GoExpression#literalFloat.
	VisitLiteralFloat(ctx *LiteralFloatContext) interface{}

	// Visit a parse tree produced by GoExpression#literalImag.
	VisitLiteralImag(ctx *LiteralImagContext) interface{}

	// Visit a parse tree produced by GoExpression#operandName.
	VisitOperandName(ctx *OperandNameContext) interface{}

	// Visit a parse tree produced by GoExpression#field.
	VisitField(ctx *FieldContext) interface{}

	// Visit a parse tree produced by GoExpression#index.
	VisitIndex(ctx *IndexContext) interface{}

	// Visit a parse tree produced by GoExpression#slice.
	VisitSlice(ctx *SliceContext) interface{}

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

	// Visit a parse tree produced by GoExpression#expressionList.
	VisitExpressionList(ctx *ExpressionListContext) interface{}
}

A complete Visitor for a parse tree produced by GoExpression.

type GoLexer 

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

func NewGoLexer 

func NewGoLexer(input antlr.CharStream) *GoLexer

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

type IArgumentsContext 

type IArgumentsContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	L_PAREN() antlr.TerminalNode
	R_PAREN() antlr.TerminalNode
	ExpressionList() IExpressionListContext
	ELLIPSIS() antlr.TerminalNode
	COMMA() antlr.TerminalNode

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

IArgumentsContext is an interface to support dynamic dispatch.

type IExpressionContext 

type IExpressionContext interface {
	antlr.ParserRuleContext

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

	// GetUnary_op returns the unary_op token.
	GetUnary_op() antlr.Token

	// GetMul_op returns the mul_op token.
	GetMul_op() antlr.Token

	// GetAdd_op returns the add_op token.
	GetAdd_op() antlr.Token

	// GetRel_op returns the rel_op token.
	GetRel_op() antlr.Token

	// SetUnary_op sets the unary_op token.
	SetUnary_op(antlr.Token)

	// SetMul_op sets the mul_op token.
	SetMul_op(antlr.Token)

	// SetAdd_op sets the add_op token.
	SetAdd_op(antlr.Token)

	// SetRel_op sets the rel_op token.
	SetRel_op(antlr.Token)

	// Getter signatures
	PrimaryExpr() IPrimaryExprContext
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode
	EXCLAMATION() antlr.TerminalNode
	CARET() antlr.TerminalNode
	STAR() antlr.TerminalNode
	AMPERSAND() antlr.TerminalNode
	RECEIVE() antlr.TerminalNode
	DIV() antlr.TerminalNode
	MOD() antlr.TerminalNode
	LSHIFT() antlr.TerminalNode
	RSHIFT() antlr.TerminalNode
	BIT_CLEAR() antlr.TerminalNode
	OR() antlr.TerminalNode
	EQUALS() antlr.TerminalNode
	NOT_EQUALS() antlr.TerminalNode
	LESS() antlr.TerminalNode
	LESS_OR_EQUALS() antlr.TerminalNode
	GREATER() antlr.TerminalNode
	GREATER_OR_EQUALS() antlr.TerminalNode
	LOGICAL_AND() antlr.TerminalNode
	LOGICAL_OR() antlr.TerminalNode
	Question() antlr.TerminalNode
	COLON() antlr.TerminalNode

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

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionListContext 

type IExpressionListContext interface {
	antlr.ParserRuleContext

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

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

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

IExpressionListContext is an interface to support dynamic dispatch.

type IFieldContext 

type IFieldContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	SafeIndex() antlr.TerminalNode
	IDENTIFIER() antlr.TerminalNode
	DOT() antlr.TerminalNode

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

IFieldContext is an interface to support dynamic dispatch.

type IIndexContext 

type IIndexContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	L_BRACKET() antlr.TerminalNode
	Expression() IExpressionContext
	R_BRACKET() antlr.TerminalNode

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

IIndexContext is an interface to support dynamic dispatch.

type IIntegerContext 

type IIntegerContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	DECIMAL_LIT() antlr.TerminalNode
	BINARY_LIT() antlr.TerminalNode
	OCTAL_LIT() antlr.TerminalNode
	HEX_LIT() antlr.TerminalNode

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

IIntegerContext is an interface to support dynamic dispatch.

type ILiteralContext 

type ILiteralContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	LiteralNil() ILiteralNilContext
	Integer() IIntegerContext
	String_() IStringContext
	LiteralFloat() ILiteralFloatContext
	LiteralImag() ILiteralImagContext

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

ILiteralContext is an interface to support dynamic dispatch.

type ILiteralFloatContext 

type ILiteralFloatContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	FLOAT_LIT() antlr.TerminalNode

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

ILiteralFloatContext is an interface to support dynamic dispatch.

type ILiteralImagContext 

type ILiteralImagContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IMAGINARY_LIT() antlr.TerminalNode

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

ILiteralImagContext is an interface to support dynamic dispatch.

type ILiteralNilContext 

type ILiteralNilContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	NIL_LIT() antlr.TerminalNode

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

ILiteralNilContext is an interface to support dynamic dispatch.

type IOperandContext 

type IOperandContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	Literal() ILiteralContext
	OperandName() IOperandNameContext
	L_PAREN() antlr.TerminalNode
	Expression() IExpressionContext
	R_PAREN() antlr.TerminalNode

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

IOperandContext is an interface to support dynamic dispatch.

type IOperandNameContext 

type IOperandNameContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode

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

IOperandNameContext is an interface to support dynamic dispatch.

type IPrimaryExprContext 

type IPrimaryExprContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	Operand() IOperandContext
	PrimaryExpr() IPrimaryExprContext
	Field() IFieldContext
	Index() IIndexContext
	Slice() ISliceContext
	Arguments() IArgumentsContext

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

IPrimaryExprContext is an interface to support dynamic dispatch.

type ISliceContext 

type ISliceContext interface {
	antlr.ParserRuleContext

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

	// GetLo returns the lo rule contexts.
	GetLo() IExpressionContext

	// GetHi returns the hi rule contexts.
	GetHi() IExpressionContext

	// GetCap_ returns the cap_ rule contexts.
	GetCap_() IExpressionContext

	// SetLo sets the lo rule contexts.
	SetLo(IExpressionContext)

	// SetHi sets the hi rule contexts.
	SetHi(IExpressionContext)

	// SetCap_ sets the cap_ rule contexts.
	SetCap_(IExpressionContext)

	// Getter signatures
	L_BRACKET() antlr.TerminalNode
	R_BRACKET() antlr.TerminalNode
	AllCOLON() []antlr.TerminalNode
	COLON(i int) antlr.TerminalNode
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext

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

ISliceContext is an interface to support dynamic dispatch.

type IStringContext 

type IStringContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	RAW_STRING_LIT() antlr.TerminalNode
	INTERPRETED_STRING_LIT() antlr.TerminalNode
	SINGER_QUOT_STRING_LIT() antlr.TerminalNode

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

IStringContext is an interface to support dynamic dispatch.

type IndexContext 

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

func NewEmptyIndexContext 

func NewEmptyIndexContext() *IndexContext

func NewIndexContext 

func NewIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexContext

func (*IndexContext) Accept 

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

func (*IndexContext) EnterRule 

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

func (*IndexContext) ExitRule 

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

func (*IndexContext) Expression 

func (s *IndexContext) Expression() IExpressionContext

func (*IndexContext) GetParser 

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

func (*IndexContext) GetRuleContext 

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

func (*IndexContext) IsIndexContext 

func (*IndexContext) IsIndexContext()

func (*IndexContext) L_BRACKET 

func (s *IndexContext) L_BRACKET() antlr.TerminalNode

func (*IndexContext) R_BRACKET 

func (s *IndexContext) R_BRACKET() antlr.TerminalNode

func (*IndexContext) ToStringTree 

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

type IntegerContext 

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

func NewEmptyIntegerContext 

func NewEmptyIntegerContext() *IntegerContext

func NewIntegerContext 

func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerContext

func (*IntegerContext) Accept 

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

func (*IntegerContext) BINARY_LIT 

func (s *IntegerContext) BINARY_LIT() antlr.TerminalNode

func (*IntegerContext) DECIMAL_LIT 

func (s *IntegerContext) DECIMAL_LIT() antlr.TerminalNode

func (*IntegerContext) EnterRule 

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

func (*IntegerContext) ExitRule 

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

func (*IntegerContext) GetParser 

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

func (*IntegerContext) GetRuleContext 

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

func (*IntegerContext) HEX_LIT 

func (s *IntegerContext) HEX_LIT() antlr.TerminalNode

func (*IntegerContext) IsIntegerContext 

func (*IntegerContext) IsIntegerContext()

func (*IntegerContext) OCTAL_LIT 

func (s *IntegerContext) OCTAL_LIT() antlr.TerminalNode

func (*IntegerContext) ToStringTree 

func (s *IntegerContext) 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) EnterRule 

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

func (*LiteralContext) ExitRule 

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

func (*LiteralContext) GetParser 

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

func (*LiteralContext) GetRuleContext 

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

func (*LiteralContext) Integer 

func (s *LiteralContext) Integer() IIntegerContext

func (*LiteralContext) IsLiteralContext 

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) LiteralFloat 

func (s *LiteralContext) LiteralFloat() ILiteralFloatContext

func (*LiteralContext) LiteralImag 

func (s *LiteralContext) LiteralImag() ILiteralImagContext

func (*LiteralContext) LiteralNil 

func (s *LiteralContext) LiteralNil() ILiteralNilContext

func (*LiteralContext) String_ 

func (s *LiteralContext) String_() IStringContext

func (*LiteralContext) ToStringTree 

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

type LiteralFloatContext 

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

func NewEmptyLiteralFloatContext 

func NewEmptyLiteralFloatContext() *LiteralFloatContext

func NewLiteralFloatContext 

func NewLiteralFloatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralFloatContext

func (*LiteralFloatContext) Accept 

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

func (*LiteralFloatContext) EnterRule 

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

func (*LiteralFloatContext) ExitRule 

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

func (*LiteralFloatContext) FLOAT_LIT 

func (s *LiteralFloatContext) FLOAT_LIT() antlr.TerminalNode

func (*LiteralFloatContext) GetParser 

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

func (*LiteralFloatContext) GetRuleContext 

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

func (*LiteralFloatContext) IsLiteralFloatContext 

func (*LiteralFloatContext) IsLiteralFloatContext()

func (*LiteralFloatContext) ToStringTree 

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

type LiteralImagContext 

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

func NewEmptyLiteralImagContext 

func NewEmptyLiteralImagContext() *LiteralImagContext

func NewLiteralImagContext 

func NewLiteralImagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralImagContext

func (*LiteralImagContext) Accept 

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

func (*LiteralImagContext) EnterRule 

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

func (*LiteralImagContext) ExitRule 

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

func (*LiteralImagContext) GetParser 

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

func (*LiteralImagContext) GetRuleContext 

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

func (*LiteralImagContext) IMAGINARY_LIT 

func (s *LiteralImagContext) IMAGINARY_LIT() antlr.TerminalNode

func (*LiteralImagContext) IsLiteralImagContext 

func (*LiteralImagContext) IsLiteralImagContext()

func (*LiteralImagContext) ToStringTree 

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

type LiteralNilContext 

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

func NewEmptyLiteralNilContext 

func NewEmptyLiteralNilContext() *LiteralNilContext

func NewLiteralNilContext 

func NewLiteralNilContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralNilContext

func (*LiteralNilContext) Accept 

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

func (*LiteralNilContext) EnterRule 

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

func (*LiteralNilContext) ExitRule 

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

func (*LiteralNilContext) GetParser 

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

func (*LiteralNilContext) GetRuleContext 

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

func (*LiteralNilContext) IsLiteralNilContext 

func (*LiteralNilContext) IsLiteralNilContext()

func (*LiteralNilContext) NIL_LIT 

func (s *LiteralNilContext) NIL_LIT() antlr.TerminalNode

func (*LiteralNilContext) ToStringTree 

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

type OperandContext 

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

func NewEmptyOperandContext 

func NewEmptyOperandContext() *OperandContext

func NewOperandContext 

func NewOperandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperandContext

func (*OperandContext) Accept 

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

func (*OperandContext) EnterRule 

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

func (*OperandContext) ExitRule 

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

func (*OperandContext) Expression 

func (s *OperandContext) Expression() IExpressionContext

func (*OperandContext) GetParser 

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

func (*OperandContext) GetRuleContext 

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

func (*OperandContext) IsOperandContext 

func (*OperandContext) IsOperandContext()

func (*OperandContext) L_PAREN 

func (s *OperandContext) L_PAREN() antlr.TerminalNode

func (*OperandContext) Literal 

func (s *OperandContext) Literal() ILiteralContext

func (*OperandContext) OperandName 

func (s *OperandContext) OperandName() IOperandNameContext

func (*OperandContext) R_PAREN 

func (s *OperandContext) R_PAREN() antlr.TerminalNode

func (*OperandContext) ToStringTree 

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

type OperandNameContext 

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

func NewEmptyOperandNameContext 

func NewEmptyOperandNameContext() *OperandNameContext

func NewOperandNameContext 

func NewOperandNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperandNameContext

func (*OperandNameContext) Accept 

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

func (*OperandNameContext) EnterRule 

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

func (*OperandNameContext) ExitRule 

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

func (*OperandNameContext) GetParser 

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

func (*OperandNameContext) GetRuleContext 

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

func (*OperandNameContext) IDENTIFIER 

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

func (*OperandNameContext) IsOperandNameContext 

func (*OperandNameContext) IsOperandNameContext()

func (*OperandNameContext) ToStringTree 

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

type PrimaryExprContext 

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

func NewEmptyPrimaryExprContext 

func NewEmptyPrimaryExprContext() *PrimaryExprContext

func NewPrimaryExprContext 

func NewPrimaryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExprContext

func (*PrimaryExprContext) Accept 

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

func (*PrimaryExprContext) Arguments 

func (s *PrimaryExprContext) Arguments() IArgumentsContext

func (*PrimaryExprContext) EnterRule 

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

func (*PrimaryExprContext) ExitRule 

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

func (*PrimaryExprContext) Field 

func (s *PrimaryExprContext) Field() IFieldContext

func (*PrimaryExprContext) GetParser 

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

func (*PrimaryExprContext) GetRuleContext 

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

func (*PrimaryExprContext) Index 

func (s *PrimaryExprContext) Index() IIndexContext

func (*PrimaryExprContext) IsPrimaryExprContext 

func (*PrimaryExprContext) IsPrimaryExprContext()

func (*PrimaryExprContext) Operand 

func (s *PrimaryExprContext) Operand() IOperandContext

func (*PrimaryExprContext) PrimaryExpr 

func (s *PrimaryExprContext) PrimaryExpr() IPrimaryExprContext

func (*PrimaryExprContext) Slice 

func (s *PrimaryExprContext) Slice() ISliceContext

func (*PrimaryExprContext) ToStringTree 

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

type SliceContext 

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

func NewEmptySliceContext 

func NewEmptySliceContext() *SliceContext

func NewSliceContext 

func NewSliceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SliceContext

func (*SliceContext) Accept 

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

func (*SliceContext) AllCOLON 

func (s *SliceContext) AllCOLON() []antlr.TerminalNode

func (*SliceContext) AllExpression 

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

func (*SliceContext) COLON 

func (s *SliceContext) COLON(i int) antlr.TerminalNode

func (*SliceContext) EnterRule 

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

func (*SliceContext) ExitRule 

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

func (*SliceContext) Expression 

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

func (*SliceContext) GetCap_ 

func (s *SliceContext) GetCap_() IExpressionContext

func (*SliceContext) GetHi 

func (s *SliceContext) GetHi() IExpressionContext

func (*SliceContext) GetLo 

func (s *SliceContext) GetLo() IExpressionContext

func (*SliceContext) GetParser 

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

func (*SliceContext) GetRuleContext 

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

func (*SliceContext) IsSliceContext 

func (*SliceContext) IsSliceContext()

func (*SliceContext) L_BRACKET 

func (s *SliceContext) L_BRACKET() antlr.TerminalNode

func (*SliceContext) R_BRACKET 

func (s *SliceContext) R_BRACKET() antlr.TerminalNode

func (*SliceContext) SetCap_ 

func (s *SliceContext) SetCap_(v IExpressionContext)

func (*SliceContext) SetHi 

func (s *SliceContext) SetHi(v IExpressionContext)

func (*SliceContext) SetLo 

func (s *SliceContext) SetLo(v IExpressionContext)

func (*SliceContext) ToStringTree 

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

type StringContext 

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

func NewEmptyStringContext 

func NewEmptyStringContext() *StringContext

func NewStringContext 

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

func (*StringContext) Accept 

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

func (*StringContext) EnterRule 

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

func (*StringContext) ExitRule 

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

func (*StringContext) GetParser 

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

func (*StringContext) GetRuleContext 

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

func (*StringContext) INTERPRETED_STRING_LIT 

func (s *StringContext) INTERPRETED_STRING_LIT() antlr.TerminalNode

func (*StringContext) IsStringContext 

func (*StringContext) IsStringContext()

func (*StringContext) RAW_STRING_LIT 

func (s *StringContext) RAW_STRING_LIT() antlr.TerminalNode

func (*StringContext) SINGER_QUOT_STRING_LIT 

func (s *StringContext) SINGER_QUOT_STRING_LIT() antlr.TerminalNode

func (*StringContext) ToStringTree 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.