expression

package
v0.0.0-...-0f5f40a Latest Latest
Warning

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

 Go to latest Published: Sep 19, 2024 License: GPL-3.0, MIT Imports: 25 Imported by: 0

README

README

THIS CODE IS FROM https://github.com/raylax/rayx

LICENSE: MIT License

THANKS

Documentation

Index

Constants

View Source 
const (
	ExpressionLexerT__0                 = 1
	ExpressionLexerT__1                 = 2
	ExpressionLexerT__2                 = 3
	ExpressionLexerT__3                 = 4
	ExpressionLexerT__4                 = 5
	ExpressionLexerT__5                 = 6
	ExpressionLexerDOT                  = 7
	ExpressionLexerLBRACK               = 8
	ExpressionLexerRBRACK               = 9
	ExpressionLexerLPAREN               = 10
	ExpressionLexerRPAREN               = 11
	ExpressionLexerPLUS                 = 12
	ExpressionLexerMINUS                = 13
	ExpressionLexerMULTIPLY             = 14
	ExpressionLexerDIVIDE               = 15
	ExpressionLexerEQUAL                = 16
	ExpressionLexerNOTEQUAL             = 17
	ExpressionLexerWhiteSpaces          = 18
	ExpressionLexerBooleanLiteral       = 19
	ExpressionLexerIdentifier           = 20
	ExpressionLexerIntegerLiteral       = 21
	ExpressionLexerFloatingPointLiteral = 22
	ExpressionLexerStringLiteral        = 23
	ExpressionLexerWhitespace           = 24
)

ExpressionLexer tokens.

View Source 
const (
	ExpressionParserEOF                  = antlr.TokenEOF
	ExpressionParserT__0                 = 1
	ExpressionParserT__1                 = 2
	ExpressionParserT__2                 = 3
	ExpressionParserT__3                 = 4
	ExpressionParserT__4                 = 5
	ExpressionParserT__5                 = 6
	ExpressionParserDOT                  = 7
	ExpressionParserLBRACK               = 8
	ExpressionParserRBRACK               = 9
	ExpressionParserLPAREN               = 10
	ExpressionParserRPAREN               = 11
	ExpressionParserPLUS                 = 12
	ExpressionParserMINUS                = 13
	ExpressionParserMULTIPLY             = 14
	ExpressionParserDIVIDE               = 15
	ExpressionParserEQUAL                = 16
	ExpressionParserNOTEQUAL             = 17
	ExpressionParserWhiteSpaces          = 18
	ExpressionParserBooleanLiteral       = 19
	ExpressionParserIdentifier           = 20
	ExpressionParserIntegerLiteral       = 21
	ExpressionParserFloatingPointLiteral = 22
	ExpressionParserStringLiteral        = 23
	ExpressionParserWhitespace           = 24
)

ExpressionParser tokens.

View Source 
const (
	ExpressionParserRULE_expression          = 0
	ExpressionParserRULE_expressionSingle    = 1
	ExpressionParserRULE_expressionMember    = 2
	ExpressionParserRULE_expressionConst     = 3
	ExpressionParserRULE_expressionArguments = 4
	ExpressionParserRULE_expressionArgument  = 5
)

ExpressionParser rules.

Variables

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

Functions

func ExpressionLexerInit 

func ExpressionLexerInit()

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

func ExpressionParserInit 

func ExpressionParserInit()

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

func InitEmptyExpressionArgumentContext 

func InitEmptyExpressionArgumentContext(p *ExpressionArgumentContext)

func InitEmptyExpressionArgumentsContext 

func InitEmptyExpressionArgumentsContext(p *ExpressionArgumentsContext)

func InitEmptyExpressionConstContext 

func InitEmptyExpressionConstContext(p *ExpressionConstContext)

func InitEmptyExpressionContext 

func InitEmptyExpressionContext(p *ExpressionContext)

func InitEmptyExpressionMemberContext 

func InitEmptyExpressionMemberContext(p *ExpressionMemberContext)

func InitEmptyExpressionSingleContext 

func InitEmptyExpressionSingleContext(p *ExpressionSingleContext)

Types

type AdditiveExpressionContext 

type AdditiveExpressionContext struct {
	ExpressionSingleContext
}

func NewAdditiveExpressionContext 

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

func (*AdditiveExpressionContext) AllExpressionSingle 

func (s *AdditiveExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*AdditiveExpressionContext) EnterRule 

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

func (*AdditiveExpressionContext) ExitRule 

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

func (*AdditiveExpressionContext) ExpressionSingle 

func (s *AdditiveExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*AdditiveExpressionContext) GetRuleContext 

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

func (*AdditiveExpressionContext) MINUS 

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

func (*AdditiveExpressionContext) PLUS 

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

type ArrayAccessExpressionContext 

type ArrayAccessExpressionContext struct {
	ExpressionSingleContext
}

func NewArrayAccessExpressionContext 

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

func (*ArrayAccessExpressionContext) EnterRule 

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

func (*ArrayAccessExpressionContext) ExitRule 

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

func (*ArrayAccessExpressionContext) ExpressionSingle 

func (s *ArrayAccessExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*ArrayAccessExpressionContext) GetRuleContext 

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

func (*ArrayAccessExpressionContext) IntegerLiteral 

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

func (*ArrayAccessExpressionContext) LBRACK 

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

func (*ArrayAccessExpressionContext) RBRACK 

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

type BaseExpressionListener 

type BaseExpressionListener struct{}

BaseExpressionListener is a complete listener for a parse tree produced by ExpressionParser.

func (*BaseExpressionListener) EnterAdditiveExpression 

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

EnterAdditiveExpression is called when production AdditiveExpression is entered.

func (*BaseExpressionListener) EnterArrayAccessExpression 

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

EnterArrayAccessExpression is called when production ArrayAccessExpression is entered.

func (*BaseExpressionListener) EnterBinaryStringLiteral 

func (s *BaseExpressionListener) EnterBinaryStringLiteral(ctx *BinaryStringLiteralContext)

EnterBinaryStringLiteral is called when production BinaryStringLiteral is entered.

func (*BaseExpressionListener) EnterBooleanLiteral 

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

EnterBooleanLiteral is called when production BooleanLiteral is entered.

func (*BaseExpressionListener) EnterConstExpression 

func (s *BaseExpressionListener) EnterConstExpression(ctx *ConstExpressionContext)

EnterConstExpression is called when production ConstExpression is entered.

func (*BaseExpressionListener) EnterEqualityExpression 

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

EnterEqualityExpression is called when production EqualityExpression is entered.

func (*BaseExpressionListener) EnterEveryRule 

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

EnterEveryRule is called when any rule is entered.

func (*BaseExpressionListener) EnterExpression 

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

EnterExpression is called when production expression is entered.

func (*BaseExpressionListener) EnterExpressionArgument 

func (s *BaseExpressionListener) EnterExpressionArgument(ctx *ExpressionArgumentContext)

EnterExpressionArgument is called when production expressionArgument is entered.

func (*BaseExpressionListener) EnterExpressionArguments 

func (s *BaseExpressionListener) EnterExpressionArguments(ctx *ExpressionArgumentsContext)

EnterExpressionArguments is called when production expressionArguments is entered.

func (*BaseExpressionListener) EnterExpressionMember 

func (s *BaseExpressionListener) EnterExpressionMember(ctx *ExpressionMemberContext)

EnterExpressionMember is called when production expressionMember is entered.

func (*BaseExpressionListener) EnterFloatingPointLiteral 

func (s *BaseExpressionListener) EnterFloatingPointLiteral(ctx *FloatingPointLiteralContext)

EnterFloatingPointLiteral is called when production FloatingPointLiteral is entered.

func (*BaseExpressionListener) EnterFunctionCallExpression 

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

EnterFunctionCallExpression is called when production FunctionCallExpression is entered.

func (*BaseExpressionListener) EnterIdentifierAccessExpression 

func (s *BaseExpressionListener) EnterIdentifierAccessExpression(ctx *IdentifierAccessExpressionContext)

EnterIdentifierAccessExpression is called when production IdentifierAccessExpression is entered.

func (*BaseExpressionListener) EnterInExpression 

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

EnterInExpression is called when production InExpression is entered.

func (*BaseExpressionListener) EnterIntegerLiteral 

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

EnterIntegerLiteral is called when production IntegerLiteral is entered.

func (*BaseExpressionListener) EnterLogicalAndExpression 

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

EnterLogicalAndExpression is called when production LogicalAndExpression is entered.

func (*BaseExpressionListener) EnterLogicalOrExpression 

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

EnterLogicalOrExpression is called when production LogicalOrExpression is entered.

func (*BaseExpressionListener) EnterMemberAccessExpression 

func (s *BaseExpressionListener) EnterMemberAccessExpression(ctx *MemberAccessExpressionContext)

EnterMemberAccessExpression is called when production MemberAccessExpression is entered.

func (*BaseExpressionListener) EnterMultiplicativeExpression 

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

EnterMultiplicativeExpression is called when production MultiplicativeExpression is entered.

func (*BaseExpressionListener) EnterNotExpression 

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

EnterNotExpression is called when production NotExpression is entered.

func (*BaseExpressionListener) EnterParenExpression 

func (s *BaseExpressionListener) EnterParenExpression(ctx *ParenExpressionContext)

EnterParenExpression is called when production ParenExpression is entered.

func (*BaseExpressionListener) EnterStringLiteral 

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

EnterStringLiteral is called when production StringLiteral is entered.

func (*BaseExpressionListener) ExitAdditiveExpression 

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

ExitAdditiveExpression is called when production AdditiveExpression is exited.

func (*BaseExpressionListener) ExitArrayAccessExpression 

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

ExitArrayAccessExpression is called when production ArrayAccessExpression is exited.

func (*BaseExpressionListener) ExitBinaryStringLiteral 

func (s *BaseExpressionListener) ExitBinaryStringLiteral(ctx *BinaryStringLiteralContext)

ExitBinaryStringLiteral is called when production BinaryStringLiteral is exited.

func (*BaseExpressionListener) ExitBooleanLiteral 

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

ExitBooleanLiteral is called when production BooleanLiteral is exited.

func (*BaseExpressionListener) ExitConstExpression 

func (s *BaseExpressionListener) ExitConstExpression(ctx *ConstExpressionContext)

ExitConstExpression is called when production ConstExpression is exited.

func (*BaseExpressionListener) ExitEqualityExpression 

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

ExitEqualityExpression is called when production EqualityExpression is exited.

func (*BaseExpressionListener) ExitEveryRule 

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

ExitEveryRule is called when any rule is exited.

func (*BaseExpressionListener) ExitExpression 

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

ExitExpression is called when production expression is exited.

func (*BaseExpressionListener) ExitExpressionArgument 

func (s *BaseExpressionListener) ExitExpressionArgument(ctx *ExpressionArgumentContext)

ExitExpressionArgument is called when production expressionArgument is exited.

func (*BaseExpressionListener) ExitExpressionArguments 

func (s *BaseExpressionListener) ExitExpressionArguments(ctx *ExpressionArgumentsContext)

ExitExpressionArguments is called when production expressionArguments is exited.

func (*BaseExpressionListener) ExitExpressionMember 

func (s *BaseExpressionListener) ExitExpressionMember(ctx *ExpressionMemberContext)

ExitExpressionMember is called when production expressionMember is exited.

func (*BaseExpressionListener) ExitFloatingPointLiteral 

func (s *BaseExpressionListener) ExitFloatingPointLiteral(ctx *FloatingPointLiteralContext)

ExitFloatingPointLiteral is called when production FloatingPointLiteral is exited.

func (*BaseExpressionListener) ExitFunctionCallExpression 

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

ExitFunctionCallExpression is called when production FunctionCallExpression is exited.

func (*BaseExpressionListener) ExitIdentifierAccessExpression 

func (s *BaseExpressionListener) ExitIdentifierAccessExpression(ctx *IdentifierAccessExpressionContext)

ExitIdentifierAccessExpression is called when production IdentifierAccessExpression is exited.

func (*BaseExpressionListener) ExitInExpression 

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

ExitInExpression is called when production InExpression is exited.

func (*BaseExpressionListener) ExitIntegerLiteral 

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

ExitIntegerLiteral is called when production IntegerLiteral is exited.

func (*BaseExpressionListener) ExitLogicalAndExpression 

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

ExitLogicalAndExpression is called when production LogicalAndExpression is exited.

func (*BaseExpressionListener) ExitLogicalOrExpression 

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

ExitLogicalOrExpression is called when production LogicalOrExpression is exited.

func (*BaseExpressionListener) ExitMemberAccessExpression 

func (s *BaseExpressionListener) ExitMemberAccessExpression(ctx *MemberAccessExpressionContext)

ExitMemberAccessExpression is called when production MemberAccessExpression is exited.

func (*BaseExpressionListener) ExitMultiplicativeExpression 

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

ExitMultiplicativeExpression is called when production MultiplicativeExpression is exited.

func (*BaseExpressionListener) ExitNotExpression 

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

ExitNotExpression is called when production NotExpression is exited.

func (*BaseExpressionListener) ExitParenExpression 

func (s *BaseExpressionListener) ExitParenExpression(ctx *ParenExpressionContext)

ExitParenExpression is called when production ParenExpression is exited.

func (*BaseExpressionListener) ExitStringLiteral 

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

ExitStringLiteral is called when production StringLiteral is exited.

func (*BaseExpressionListener) VisitErrorNode 

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

VisitErrorNode is called when an error node is visited.

func (*BaseExpressionListener) VisitTerminal 

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

VisitTerminal is called when a terminal node is visited.

type BinaryStringLiteralContext 

type BinaryStringLiteralContext struct {
	ExpressionConstContext
}

func NewBinaryStringLiteralContext 

func NewBinaryStringLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryStringLiteralContext

func (*BinaryStringLiteralContext) EnterRule 

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

func (*BinaryStringLiteralContext) ExitRule 

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

func (*BinaryStringLiteralContext) GetRuleContext 

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

func (*BinaryStringLiteralContext) StringLiteral 

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

type BooleanLiteralContext 

type BooleanLiteralContext struct {
	ExpressionConstContext
}

func NewBooleanLiteralContext 

func NewBooleanLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BooleanLiteralContext

func (*BooleanLiteralContext) BooleanLiteral 

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

func (*BooleanLiteralContext) EnterRule 

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

func (*BooleanLiteralContext) ExitRule 

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

func (*BooleanLiteralContext) GetRuleContext 

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

type ConstExpressionContext 

type ConstExpressionContext struct {
	ExpressionSingleContext
}

func NewConstExpressionContext 

func NewConstExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstExpressionContext

func (*ConstExpressionContext) EnterRule 

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

func (*ConstExpressionContext) ExitRule 

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

func (*ConstExpressionContext) ExpressionConst 

func (s *ConstExpressionContext) ExpressionConst() IExpressionConstContext

func (*ConstExpressionContext) GetRuleContext 

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

type EBool 

type EBool bool

func (EBool) ToString 

func (v EBool) ToString() EString

type EBytes 

type EBytes []byte

func (EBytes) Get 

func (v EBytes) Get(name string) (EValue, error)

func (EBytes) Keys 

func (v EBytes) Keys() []string

func (EBytes) ToString 

func (v EBytes) ToString() EString

type EFloat 

type EFloat float64

func (EFloat) ToString 

func (v EFloat) ToString() EString

type EFunction 

type EFunction interface {
	Call(args []EValue) (EValue, error)
	ToString() EString
}

EFunction 函数

type EInt 

type EInt int

func (EInt) ToString 

func (v EInt) ToString() EString

type EObject 

type EObject interface {
	EValue
	Get(name string) (EValue, error)
	Keys() []string
}

EObject 对象

type EString 

type EString string

func (EString) Get 

func (v EString) Get(name string) (EValue, error)

func (EString) Keys 

func (v EString) Keys() []string

func (EString) ToString 

func (v EString) ToString() EString

type EValue 

type EValue interface {
	ToString() EString
}

EValue 基本类型

type Environment 

type Environment struct {
	Context context.Context
	// contains filtered or unexported fields
}

func NewEnvironment 

func NewEnvironment(context context.Context, vars ...Vars) *Environment

func (*Environment) Eval 

func (e *Environment) Eval(expression string) (EValue, error)

func (*Environment) EvalWithVars 

func (e *Environment) EvalWithVars(expression string, vars Vars) (EValue, error)

func (*Environment) GetString 

func (e *Environment) GetString(str string) (string, error)

func (*Environment) Verify 

func (e *Environment) Verify(expression string) (err error)

type EqualityExpressionContext 

type EqualityExpressionContext struct {
	ExpressionSingleContext
}

func NewEqualityExpressionContext 

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

func (*EqualityExpressionContext) AllExpressionSingle 

func (s *EqualityExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*EqualityExpressionContext) EQUAL 

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

func (*EqualityExpressionContext) EnterRule 

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

func (*EqualityExpressionContext) ExitRule 

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

func (*EqualityExpressionContext) ExpressionSingle 

func (s *EqualityExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*EqualityExpressionContext) GetRuleContext 

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

func (*EqualityExpressionContext) NOTEQUAL 

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

type ExpressionArgumentContext 

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

func NewEmptyExpressionArgumentContext 

func NewEmptyExpressionArgumentContext() *ExpressionArgumentContext

func NewExpressionArgumentContext 

func NewExpressionArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionArgumentContext

func (*ExpressionArgumentContext) EnterRule 

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

func (*ExpressionArgumentContext) ExitRule 

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

func (*ExpressionArgumentContext) ExpressionSingle 

func (s *ExpressionArgumentContext) ExpressionSingle() IExpressionSingleContext

func (*ExpressionArgumentContext) GetParser 

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

func (*ExpressionArgumentContext) GetRuleContext 

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

func (*ExpressionArgumentContext) Identifier 

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

func (*ExpressionArgumentContext) IntegerLiteral 

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

func (*ExpressionArgumentContext) IsExpressionArgumentContext 

func (*ExpressionArgumentContext) IsExpressionArgumentContext()

func (*ExpressionArgumentContext) StringLiteral 

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

func (*ExpressionArgumentContext) ToStringTree 

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

type ExpressionArgumentsContext 

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

func NewEmptyExpressionArgumentsContext 

func NewEmptyExpressionArgumentsContext() *ExpressionArgumentsContext

func NewExpressionArgumentsContext 

func NewExpressionArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionArgumentsContext

func (*ExpressionArgumentsContext) AllExpressionArgument 

func (s *ExpressionArgumentsContext) AllExpressionArgument() []IExpressionArgumentContext

func (*ExpressionArgumentsContext) EnterRule 

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

func (*ExpressionArgumentsContext) ExitRule 

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

func (*ExpressionArgumentsContext) ExpressionArgument 

func (s *ExpressionArgumentsContext) ExpressionArgument(i int) IExpressionArgumentContext

func (*ExpressionArgumentsContext) GetParser 

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

func (*ExpressionArgumentsContext) GetRuleContext 

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

func (*ExpressionArgumentsContext) IsExpressionArgumentsContext 

func (*ExpressionArgumentsContext) IsExpressionArgumentsContext()

func (*ExpressionArgumentsContext) ToStringTree 

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

type ExpressionConstContext 

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

func NewEmptyExpressionConstContext 

func NewEmptyExpressionConstContext() *ExpressionConstContext

func NewExpressionConstContext 

func NewExpressionConstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionConstContext

func (*ExpressionConstContext) CopyAll 

func (s *ExpressionConstContext) CopyAll(ctx *ExpressionConstContext)

func (*ExpressionConstContext) GetParser 

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

func (*ExpressionConstContext) GetRuleContext 

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

func (*ExpressionConstContext) IsExpressionConstContext 

func (*ExpressionConstContext) IsExpressionConstContext()

func (*ExpressionConstContext) ToStringTree 

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

type ExpressionContext 

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

func NewEmptyExpressionContext 

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext 

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

func (*ExpressionContext) EOF 

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

func (*ExpressionContext) EnterRule 

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

func (*ExpressionContext) ExitRule 

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

func (*ExpressionContext) ExpressionSingle 

func (s *ExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*ExpressionContext) GetParser 

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

func (*ExpressionContext) GetRuleContext 

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

func (*ExpressionContext) IsExpressionContext 

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) ToStringTree 

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

type ExpressionLexer 

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

func NewExpressionLexer 

func NewExpressionLexer(input antlr.CharStream) *ExpressionLexer

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

type ExpressionListener 

type ExpressionListener interface {
	antlr.ParseTreeListener

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

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

	// EnterMemberAccessExpression is called when entering the MemberAccessExpression production.
	EnterMemberAccessExpression(c *MemberAccessExpressionContext)

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

	// EnterConstExpression is called when entering the ConstExpression production.
	EnterConstExpression(c *ConstExpressionContext)

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

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

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

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

	// EnterParenExpression is called when entering the ParenExpression production.
	EnterParenExpression(c *ParenExpressionContext)

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

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

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

	// EnterIdentifierAccessExpression is called when entering the IdentifierAccessExpression production.
	EnterIdentifierAccessExpression(c *IdentifierAccessExpressionContext)

	// EnterExpressionMember is called when entering the expressionMember production.
	EnterExpressionMember(c *ExpressionMemberContext)

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

	// EnterBinaryStringLiteral is called when entering the BinaryStringLiteral production.
	EnterBinaryStringLiteral(c *BinaryStringLiteralContext)

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

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

	// EnterFloatingPointLiteral is called when entering the FloatingPointLiteral production.
	EnterFloatingPointLiteral(c *FloatingPointLiteralContext)

	// EnterExpressionArguments is called when entering the expressionArguments production.
	EnterExpressionArguments(c *ExpressionArgumentsContext)

	// EnterExpressionArgument is called when entering the expressionArgument production.
	EnterExpressionArgument(c *ExpressionArgumentContext)

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

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

	// ExitMemberAccessExpression is called when exiting the MemberAccessExpression production.
	ExitMemberAccessExpression(c *MemberAccessExpressionContext)

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

	// ExitConstExpression is called when exiting the ConstExpression production.
	ExitConstExpression(c *ConstExpressionContext)

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

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

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

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

	// ExitParenExpression is called when exiting the ParenExpression production.
	ExitParenExpression(c *ParenExpressionContext)

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

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

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

	// ExitIdentifierAccessExpression is called when exiting the IdentifierAccessExpression production.
	ExitIdentifierAccessExpression(c *IdentifierAccessExpressionContext)

	// ExitExpressionMember is called when exiting the expressionMember production.
	ExitExpressionMember(c *ExpressionMemberContext)

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

	// ExitBinaryStringLiteral is called when exiting the BinaryStringLiteral production.
	ExitBinaryStringLiteral(c *BinaryStringLiteralContext)

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

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

	// ExitFloatingPointLiteral is called when exiting the FloatingPointLiteral production.
	ExitFloatingPointLiteral(c *FloatingPointLiteralContext)

	// ExitExpressionArguments is called when exiting the expressionArguments production.
	ExitExpressionArguments(c *ExpressionArgumentsContext)

	// ExitExpressionArgument is called when exiting the expressionArgument production.
	ExitExpressionArgument(c *ExpressionArgumentContext)
}

ExpressionListener is a complete listener for a parse tree produced by ExpressionParser.

type ExpressionMemberContext 

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

func NewEmptyExpressionMemberContext 

func NewEmptyExpressionMemberContext() *ExpressionMemberContext

func NewExpressionMemberContext 

func NewExpressionMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionMemberContext

func (*ExpressionMemberContext) DOT 

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

func (*ExpressionMemberContext) EnterRule 

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

func (*ExpressionMemberContext) ExitRule 

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

func (*ExpressionMemberContext) GetParser 

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

func (*ExpressionMemberContext) GetRuleContext 

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

func (*ExpressionMemberContext) Identifier 

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

func (*ExpressionMemberContext) IsExpressionMemberContext 

func (*ExpressionMemberContext) IsExpressionMemberContext()

func (*ExpressionMemberContext) LBRACK 

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

func (*ExpressionMemberContext) RBRACK 

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

func (*ExpressionMemberContext) StringLiteral 

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

func (*ExpressionMemberContext) ToStringTree 

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

type ExpressionParser 

type ExpressionParser struct {
	*antlr.BaseParser
}

func NewExpressionParser 

func NewExpressionParser(input antlr.TokenStream) *ExpressionParser

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

func (*ExpressionParser) Expression 

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

func (*ExpressionParser) ExpressionArgument 

func (p *ExpressionParser) ExpressionArgument() (localctx IExpressionArgumentContext)

func (*ExpressionParser) ExpressionArguments 

func (p *ExpressionParser) ExpressionArguments() (localctx IExpressionArgumentsContext)

func (*ExpressionParser) ExpressionConst 

func (p *ExpressionParser) ExpressionConst() (localctx IExpressionConstContext)

func (*ExpressionParser) ExpressionMember 

func (p *ExpressionParser) ExpressionMember() (localctx IExpressionMemberContext)

func (*ExpressionParser) ExpressionSingle 

func (p *ExpressionParser) ExpressionSingle() (localctx IExpressionSingleContext)

func (*ExpressionParser) ExpressionSingle_Sempred 

func (p *ExpressionParser) ExpressionSingle_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ExpressionParser) Sempred 

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

type ExpressionSingleContext 

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

func NewEmptyExpressionSingleContext 

func NewEmptyExpressionSingleContext() *ExpressionSingleContext

func NewExpressionSingleContext 

func NewExpressionSingleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSingleContext

func (*ExpressionSingleContext) CopyAll 

func (s *ExpressionSingleContext) CopyAll(ctx *ExpressionSingleContext)

func (*ExpressionSingleContext) GetParser 

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

func (*ExpressionSingleContext) GetRuleContext 

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

func (*ExpressionSingleContext) IsExpressionSingleContext 

func (*ExpressionSingleContext) IsExpressionSingleContext()

func (*ExpressionSingleContext) ToStringTree 

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

type FloatingPointLiteralContext 

type FloatingPointLiteralContext struct {
	ExpressionConstContext
}

func NewFloatingPointLiteralContext 

func NewFloatingPointLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FloatingPointLiteralContext

func (*FloatingPointLiteralContext) EnterRule 

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

func (*FloatingPointLiteralContext) ExitRule 

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

func (*FloatingPointLiteralContext) FloatingPointLiteral 

func (s *FloatingPointLiteralContext) FloatingPointLiteral() antlr.TerminalNode

func (*FloatingPointLiteralContext) GetRuleContext 

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

type FunctionCallExpressionContext 

type FunctionCallExpressionContext struct {
	ExpressionSingleContext
}

func NewFunctionCallExpressionContext 

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

func (*FunctionCallExpressionContext) EnterRule 

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

func (*FunctionCallExpressionContext) ExitRule 

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

func (*FunctionCallExpressionContext) ExpressionArguments 

func (s *FunctionCallExpressionContext) ExpressionArguments() IExpressionArgumentsContext

func (*FunctionCallExpressionContext) ExpressionSingle 

func (s *FunctionCallExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*FunctionCallExpressionContext) GetRuleContext 

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

func (*FunctionCallExpressionContext) LPAREN 

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

func (*FunctionCallExpressionContext) RPAREN 

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

type IExpressionArgumentContext 

type IExpressionArgumentContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	Identifier() antlr.TerminalNode
	IntegerLiteral() antlr.TerminalNode
	StringLiteral() antlr.TerminalNode
	ExpressionSingle() IExpressionSingleContext

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

IExpressionArgumentContext is an interface to support dynamic dispatch.

type IExpressionArgumentsContext 

type IExpressionArgumentsContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllExpressionArgument() []IExpressionArgumentContext
	ExpressionArgument(i int) IExpressionArgumentContext

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

IExpressionArgumentsContext is an interface to support dynamic dispatch.

type IExpressionConstContext 

type IExpressionConstContext interface {
	antlr.ParserRuleContext

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

IExpressionConstContext is an interface to support dynamic dispatch.

type IExpressionContext 

type IExpressionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ExpressionSingle() IExpressionSingleContext
	EOF() antlr.TerminalNode

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

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionMemberContext 

type IExpressionMemberContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	DOT() antlr.TerminalNode
	Identifier() antlr.TerminalNode
	LBRACK() antlr.TerminalNode
	StringLiteral() antlr.TerminalNode
	RBRACK() antlr.TerminalNode

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

IExpressionMemberContext is an interface to support dynamic dispatch.

type IExpressionSingleContext 

type IExpressionSingleContext interface {
	antlr.ParserRuleContext

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

IExpressionSingleContext is an interface to support dynamic dispatch.

type IdentifierAccessExpressionContext 

type IdentifierAccessExpressionContext struct {
	ExpressionSingleContext
}

func NewIdentifierAccessExpressionContext 

func NewIdentifierAccessExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierAccessExpressionContext

func (*IdentifierAccessExpressionContext) EnterRule 

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

func (*IdentifierAccessExpressionContext) ExitRule 

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

func (*IdentifierAccessExpressionContext) GetRuleContext 

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

func (*IdentifierAccessExpressionContext) Identifier 

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

type InExpressionContext 

type InExpressionContext struct {
	ExpressionSingleContext
}

func NewInExpressionContext 

func NewInExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InExpressionContext

func (*InExpressionContext) AllExpressionSingle 

func (s *InExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*InExpressionContext) EnterRule 

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

func (*InExpressionContext) ExitRule 

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

func (*InExpressionContext) ExpressionSingle 

func (s *InExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*InExpressionContext) GetRuleContext 

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

type IntegerLiteralContext 

type IntegerLiteralContext struct {
	ExpressionConstContext
}

func NewIntegerLiteralContext 

func NewIntegerLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerLiteralContext

func (*IntegerLiteralContext) EnterRule 

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

func (*IntegerLiteralContext) ExitRule 

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

func (*IntegerLiteralContext) GetRuleContext 

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

func (*IntegerLiteralContext) IntegerLiteral 

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

type LogicalAndExpressionContext 

type LogicalAndExpressionContext struct {
	ExpressionSingleContext
}

func NewLogicalAndExpressionContext 

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

func (*LogicalAndExpressionContext) AllExpressionSingle 

func (s *LogicalAndExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*LogicalAndExpressionContext) EnterRule 

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

func (*LogicalAndExpressionContext) ExitRule 

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

func (*LogicalAndExpressionContext) ExpressionSingle 

func (s *LogicalAndExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*LogicalAndExpressionContext) GetRuleContext 

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

type LogicalOrExpressionContext 

type LogicalOrExpressionContext struct {
	ExpressionSingleContext
}

func NewLogicalOrExpressionContext 

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

func (*LogicalOrExpressionContext) AllExpressionSingle 

func (s *LogicalOrExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*LogicalOrExpressionContext) EnterRule 

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

func (*LogicalOrExpressionContext) ExitRule 

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

func (*LogicalOrExpressionContext) ExpressionSingle 

func (s *LogicalOrExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*LogicalOrExpressionContext) GetRuleContext 

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

type MapObject 

type MapObject map[string]EValue

func (MapObject) Get 

func (m MapObject) Get(name string) (EValue, error)

func (MapObject) Keys 

func (m MapObject) Keys() []string

func (MapObject) Set 

func (m MapObject) Set(name string, value EValue)

func (MapObject) ToString 

func (m MapObject) ToString() EString

type MapVars 

type MapVars map[string]EValue

func (MapVars) GetValue 

func (m MapVars) GetValue(_ *Environment, key string) (EValue, error)

func (MapVars) SetValue 

func (m MapVars) SetValue(key string, value EValue)

type MemberAccessExpressionContext 

type MemberAccessExpressionContext struct {
	ExpressionSingleContext
}

func NewMemberAccessExpressionContext 

func NewMemberAccessExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberAccessExpressionContext

func (*MemberAccessExpressionContext) EnterRule 

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

func (*MemberAccessExpressionContext) ExitRule 

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

func (*MemberAccessExpressionContext) ExpressionMember 

func (s *MemberAccessExpressionContext) ExpressionMember() IExpressionMemberContext

func (*MemberAccessExpressionContext) ExpressionSingle 

func (s *MemberAccessExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*MemberAccessExpressionContext) GetRuleContext 

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

type MultiplicativeExpressionContext 

type MultiplicativeExpressionContext struct {
	ExpressionSingleContext
}

func NewMultiplicativeExpressionContext 

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

func (*MultiplicativeExpressionContext) AllExpressionSingle 

func (s *MultiplicativeExpressionContext) AllExpressionSingle() []IExpressionSingleContext

func (*MultiplicativeExpressionContext) DIVIDE 

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

func (*MultiplicativeExpressionContext) EnterRule 

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

func (*MultiplicativeExpressionContext) ExitRule 

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

func (*MultiplicativeExpressionContext) ExpressionSingle 

func (s *MultiplicativeExpressionContext) ExpressionSingle(i int) IExpressionSingleContext

func (*MultiplicativeExpressionContext) GetRuleContext 

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

func (*MultiplicativeExpressionContext) MULTIPLY 

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

type NotExpressionContext 

type NotExpressionContext struct {
	ExpressionSingleContext
}

func NewNotExpressionContext 

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

func (*NotExpressionContext) EnterRule 

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

func (*NotExpressionContext) ExitRule 

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

func (*NotExpressionContext) ExpressionSingle 

func (s *NotExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*NotExpressionContext) GetRuleContext 

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

type ParenExpressionContext 

type ParenExpressionContext struct {
	ExpressionSingleContext
}

func NewParenExpressionContext 

func NewParenExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenExpressionContext

func (*ParenExpressionContext) EnterRule 

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

func (*ParenExpressionContext) ExitRule 

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

func (*ParenExpressionContext) ExpressionSingle 

func (s *ParenExpressionContext) ExpressionSingle() IExpressionSingleContext

func (*ParenExpressionContext) GetRuleContext 

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

func (*ParenExpressionContext) LPAREN 

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

func (*ParenExpressionContext) RPAREN 

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

type Reverse 

type Reverse struct {
	// contains filtered or unexported fields
}

func NewReverse 

func NewReverse() (*Reverse, error)

func (*Reverse) Get 

func (r *Reverse) Get(name string) (EValue, error)

func (*Reverse) Keys 

func (r *Reverse) Keys() []string

func (*Reverse) ToString 

func (r *Reverse) ToString() EString

type StringLiteralContext 

type StringLiteralContext struct {
	ExpressionConstContext
}

func NewStringLiteralContext 

func NewStringLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringLiteralContext

func (*StringLiteralContext) EnterRule 

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

func (*StringLiteralContext) ExitRule 

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

func (*StringLiteralContext) GetRuleContext 

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

func (*StringLiteralContext) StringLiteral 

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

type Vars 

type Vars interface {
	GetValue(env *Environment, key string) (EValue, error)
}

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.