ast

package
v0.0.0-...-c72f791 Latest Latest
Warning

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

Go to latest
Published: Apr 29, 2024 License: GPL-3.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddOp

type AddOp struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	LeftExpr  *Expr
	RightExpr *Expr
}

func NewAddOp

func NewAddOp(b *Builder) *AddOp

func (*AddOp) Parse

func (a *AddOp) Parse(exprCtx needle.IExprContext, ctx needle.IAdd_opContext)

type Arguments

type Arguments struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	ExprList *ExprList
	Ellipsis bool
}

func NewArguments

func NewArguments(b *Builder) *Arguments

func (*Arguments) Parse

func (a *Arguments) Parse(ctx needle.IArgumentsContext)

type ArrayExpr

type ArrayExpr struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	ExprList *ExprList
	Comma    bool
}

func NewArrayExpr

func NewArrayExpr(b *Builder) *ArrayExpr

func (*ArrayExpr) Parse

func (a *ArrayExpr) Parse(ctx needle.IArrayExprContext)

type Assignment

type Assignment struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	LeftExpr  []*Expr
	RightExpr []*Expr
}

func NewAssignment

func NewAssignment(b *Builder) *Assignment

func (*Assignment) Parse

func (a *Assignment) Parse(ctx needle.IAssignmentContext)

type Block

type Block struct {
	*Builder
	Id            int32
	Src           SrcPos
	TreeType      TreeType
	StatementList *StatementList
}

func NewBlock

func NewBlock(b *Builder) *Block

func (*Block) Parse

func (b *Block) Parse(ctx needle.IBlockContext)

type BreakStmt

type BreakStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
}

func NewBreakStmt

func NewBreakStmt(b *Builder) *BreakStmt

func (*BreakStmt) Parse

func (b *BreakStmt) Parse(ctx needle.IBreakStmtContext)

type Builder

type Builder struct {
	*needle.BaseNeedleParserListener

	Comments []*Comment

	Errors []error
	// contains filtered or unexported fields
}

func NewBuilder

func NewBuilder(parser *needle.NeedleParser, input []byte) *Builder

func (*Builder) AppendErr

func (b *Builder) AppendErr(err error)

func (*Builder) EnterEveryRule

func (b *Builder) EnterEveryRule(ctx antlr.ParserRuleContext)

func (*Builder) EnterSourceMain

func (b *Builder) EnterSourceMain(ctx *needle.SourceMainContext)

func (*Builder) ExitSourceMain

func (b *Builder) ExitSourceMain(ctx *needle.SourceMainContext)

func (*Builder) GetNextId

func (b *Builder) GetNextId() int32

func (*Builder) GetSourceMain

func (b *Builder) GetSourceMain() *SourceMain

type Comment

type Comment struct {
	Id       int32
	Src      SrcPos
	NodeType string
	Text     string
}

type ContinueStmt

type ContinueStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
}

func NewContinueStmt

func NewContinueStmt(b *Builder) *ContinueStmt

func (*ContinueStmt) Parse

type ContractCall

type ContractCall struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Name      string
	Arguments *Arguments
}

func NewContractCall

func NewContractCall(b *Builder) *ContractCall

func (*ContractCall) Parse

type ContractDef

type ContractDef struct {
	*Builder
	Id            int32
	Src           SrcPos
	TreeType      TreeType
	Name          string
	NamePos       SrcPos
	ContractParts []*ContractPart
}

func NewContractDef

func NewContractDef(b *Builder) *ContractDef

func (*ContractDef) Parse

func (d *ContractDef) Parse(ctx needle.IContractDefContext, main *SourceMain)

type ContractPart

type ContractPart struct {
	*Builder
	Id          int32
	Src         SrcPos
	TreeType    TreeType
	DataDef     *DataDef
	SettingsDef *SettingsDef
	FuncDef     *FuncDef
}

func NewContractPart

func NewContractPart(b *Builder) *ContractPart

func (*ContractPart) Parse

type DataDef

type DataDef struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	DataParts []*DataPart
}

func NewDataDef

func NewDataDef(b *Builder) *DataDef

func (*DataDef) Parse

func (d *DataDef) Parse(ctx *needle.DataDefContext)

type DataPart

type DataPart struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Name     string
	Typename string
	Tag      string
}

func NewDataPart

func NewDataPart(b *Builder) *DataPart

func (*DataPart) Parse

func (l *DataPart) Parse(ctx needle.IDataPartContext)

type ElseBody

type ElseBody struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Block    *Block
}

func NewElseBody

func NewElseBody(b *Builder) *ElseBody

func (*ElseBody) Parse

func (e *ElseBody) Parse(ctx needle.IElseBodyContext)

type ErrorStmt

type ErrorStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	Kind     TreeType
	TreeType TreeType
	Type     string
	Expr     *Expr
}

func NewErrorStmt

func NewErrorStmt(b *Builder) *ErrorStmt

func (*ErrorStmt) Parse

func (e *ErrorStmt) Parse(ctx needle.IErrorStmtContext)

type Expr

type Expr struct {
	*Builder
	Id           int32
	Src          SrcPos
	Kind         TreeType
	TreeType     TreeType
	PrimaryExpr  *PrimaryExpr
	IndexExpr    *IndexExpr
	SliceExpr    *SliceExpr
	MapExpr      *MapExpr
	ArrayExpr    *ArrayExpr
	ContractCall *ContractCall
	MulOp        *MulOp
	AddOp        *AddOp
	RelOp        *RelOp
	LogicalOp    *LogicalOp
	UnaryOp      *UnaryOp
}

func NewExpr

func NewExpr(b *Builder) *Expr

func (*Expr) Parse

func (e *Expr) Parse(ctx needle.IExprContext)

type ExprList

type ExprList struct {
	*Builder
	Id       int32
	Src      SrcPos
	ExprList []*Expr
}

func NewExprList

func NewExprList(b *Builder) *ExprList

func (*ExprList) Parse

func (e *ExprList) Parse(ctx needle.IExprListContext)

type FuncDef

type FuncDef struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	Name          string
	FuncSignature *FuncSignature
	Body          *Block
}

func NewFuncDef

func NewFuncDef(b *Builder) *FuncDef

func (*FuncDef) Parse

func (d *FuncDef) Parse(ctx needle.IFuncDefContext)

type FuncSignature

type FuncSignature struct {
	*Builder
	Id               int32
	Src              SrcPos
	TreeType         TreeType
	ParameterList    *ParameterList
	FuncTail         []*FuncTail
	ReturnParameters *ReturnParameters
}

func NewFuncSignature

func NewFuncSignature(b *Builder) *FuncSignature

func (*FuncSignature) HasTail

func (d *FuncSignature) HasTail() bool

func (*FuncSignature) Parse

type FuncTail

type FuncTail struct {
	*Builder
	Id            int32
	Src           SrcPos
	Name          string
	TreeType      TreeType
	ParameterList *ParameterList
}

func NewFuncTail

func NewFuncTail(b *Builder) *FuncTail

func (*FuncTail) Parse

func (d *FuncTail) Parse(ctx needle.IFuncTailContext)

type IdentifierList

type IdentifierList struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Name     []string
}

func NewIdentifierList

func NewIdentifierList(b *Builder) *IdentifierList

func (*IdentifierList) Parse

type IdentifierVar

type IdentifierVar struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Name     string
}

func NewIdentifierVar

func NewIdentifierVar(b *Builder) *IdentifierVar

func (*IdentifierVar) Parse

type IfBody

type IfBody struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Condition *Expr
	Block     *Block
}

func NewIfBody

func NewIfBody(b *Builder) *IfBody

func (*IfBody) Parse

func (i *IfBody) Parse(ctx needle.IIfBodyContext)

type IfStmt

type IfStmt struct {
	*Builder
	Id        int32
	Src       SrcPos
	Kind      TreeType
	IfBody    []*IfBody
	ElseBlock *Block
}

func NewIfStmt

func NewIfStmt(b *Builder) *IfStmt

func (*IfStmt) Parse

func (i *IfStmt) Parse(ctx needle.IIfStmtContext)

type IncDecStmt

type IncDecStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	OpPos      SrcPos
	Operator   string
	Expression *Expr
}

func NewIncDecStmt

func NewIncDecStmt(b *Builder) *IncDecStmt

func (*IncDecStmt) Parse

func (i *IncDecStmt) Parse(ctx needle.IIncDecStmtContext)

type IndexExpr

type IndexExpr struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	BaseExpr *Expr
	Index    *Expr
}

func NewIndexExpr

func NewIndexExpr(b *Builder) *IndexExpr

func (*IndexExpr) Parse

func (i *IndexExpr) Parse(exprCtx needle.IExprContext, ctx needle.IIndexExprContext)

type Literal

type Literal struct {
	*Builder
	Id              int32
	Src             SrcPos
	Kind            TreeType
	TreeType        TreeType
	Value, HexValue string
}

func NewLiteral

func NewLiteral(b *Builder) *Literal

func (*Literal) Parse

func (d *Literal) Parse(ctx needle.ILiteralContext)

type LogicalOp

type LogicalOp struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	LeftExpr  *Expr
	RightExpr *Expr
}

func NewLogicalOp

func NewLogicalOp(b *Builder) *LogicalOp

func (*LogicalOp) Parse

func (l *LogicalOp) Parse(exprCtx needle.IExprContext, ctx needle.ILogical_opContext)

type MapExpr

type MapExpr struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	PairList *PairList
}

func NewMapExpr

func NewMapExpr(b *Builder) *MapExpr

func (*MapExpr) Parse

func (o *MapExpr) Parse(ctx needle.IMapExprContext)

type MulOp

type MulOp struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	LeftExpr  *Expr
	RightExpr *Expr
}

func NewMulOp

func NewMulOp(b *Builder) *MulOp

func (*MulOp) Parse

func (m *MulOp) Parse(exprCtx needle.IExprContext, ctx needle.IMul_opContext)

type NumberLiteral

type NumberLiteral struct {
	*Builder
	Id              int32
	Src             SrcPos
	TreeType        TreeType
	Value, HexValue string
}

func NewNumberLiteral

func NewNumberLiteral(b *Builder) *NumberLiteral

func (*NumberLiteral) Parse

type Operand

type Operand struct {
	*Builder
	Id            int32
	Src           SrcPos
	TreeType      TreeType
	IdentifierVar *IdentifierVar
	Literal       *Literal
	Expr          *Expr
}

func NewOperand

func NewOperand(b *Builder) *Operand

func (*Operand) Parse

func (o *Operand) Parse(ctx needle.IOperandContext)

type OperatorType

type OperatorType int32
const (
	OperatorType_None_Default OperatorType = iota
	OperatorType_NOT
	OperatorType_MUL
	OperatorType_ADD
	OperatorType_SUB
	OperatorType_QUO
	OperatorType_LESS
	OperatorType_GREATER
	OperatorType_NOT_EQ
	OperatorType_AND
	OperatorType_LESS_EQ
	OperatorType_EQ_EQ
	OperatorType_GR_EQ
	OperatorType_OR
	OperatorType_BIT_AND
	OperatorType_BIT_OR
	OperatorType_BIT_XOR
	OperatorType_MOD
	OperatorType_LSHIFT
	OperatorType_RSHIFT
	OperatorType_ADD_EQ
	OperatorType_SUB_EQ
	OperatorType_MUL_EQ
	OperatorType_DIV_EQ
	OperatorType_MOD_EQ
	OperatorType_LSHIFT_EQ
	OperatorType_RSHIFT_EQ
	OperatorType_BIT_AND_EQ
	OperatorType_BIT_OR_EQ
	OperatorType_BIT_XOR_EQ
	OperatorType_INC
	OperatorType_DEC
)

func (OperatorType) String

func (i OperatorType) String() string

type Pair

type Pair struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Key      string
	Expr     *Expr
}

func NewPair

func NewPair(b *Builder) *Pair

func (*Pair) Parse

func (p *Pair) Parse(ctx needle.IPairContext)

type PairList

type PairList struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Pairs    []*Pair
}

func NewPairList

func NewPairList(b *Builder) *PairList

func (*PairList) Parse

func (l *PairList) Parse(ctx needle.IPairListContext)

type Parameter

type Parameter struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	NameList []*IdentifierList
	TypeName []string
}

func NewParameter

func NewParameter(b *Builder) *Parameter

func (*Parameter) Parse

func (p *Parameter) Parse(ctx needle.IParameterContext)

type ParameterList

type ParameterList struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	Parameter  *Parameter
	Variadic   bool
	Identifier string
}

func NewParameterList

func NewParameterList(b *Builder) *ParameterList

func (*ParameterList) Parse

type PrimaryExpr

type PrimaryExpr struct {
	*Builder
	Id          int32
	Src         SrcPos
	PrimaryExpr *PrimaryExpr
	TreeType    TreeType
	Operand     *Operand
	Arguments   *Arguments
}

func NewPrimaryExpr

func NewPrimaryExpr(b *Builder) *PrimaryExpr

func (*PrimaryExpr) Parse

func (p *PrimaryExpr) Parse(ctx needle.IPrimaryExprContext)

type RelOp

type RelOp struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	LeftExpr  *Expr
	RightExpr *Expr
}

func NewRelOp

func NewRelOp(b *Builder) *RelOp

func (*RelOp) Parse

func (r *RelOp) Parse(exprCtx needle.IExprContext, ctx needle.IRel_opContext)

type ReturnParameters

type ReturnParameters struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	TypeName []string
}

func NewReturnParameters

func NewReturnParameters(b *Builder) *ReturnParameters

func (*ReturnParameters) Parse

type ReturnStmt

type ReturnStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Expr     *Expr
}

func NewReturnStmt

func NewReturnStmt(b *Builder) *ReturnStmt

func (*ReturnStmt) Parse

func (r *ReturnStmt) Parse(ctx needle.IReturnStmtContext)

type SettingsDef

type SettingsDef struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType

	SettingValue []*Literal
	SettingsName []string
}

func NewSettingsDef

func NewSettingsDef(b *Builder) *SettingsDef

func (*SettingsDef) Parse

func (d *SettingsDef) Parse(ctx *needle.SettingsDefContext)

type SimpleStmt

type SimpleStmt struct {
	*Builder
	Id         int32
	Src        SrcPos
	Expr       *Expr
	IncDecStmt *IncDecStmt
	Assignment *Assignment
}

func NewSimpleStmt

func NewSimpleStmt(b *Builder) *SimpleStmt

func (*SimpleStmt) Parse

func (s *SimpleStmt) Parse(ctx needle.ISimpleStmtContext)

type SliceExpr

type SliceExpr struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	BaseExpr *Expr
	LowExpr  *Expr
	HighExpr *Expr
}

func NewSliceExpr

func NewSliceExpr(b *Builder) *SliceExpr

func (*SliceExpr) Parse

func (s *SliceExpr) Parse(exprCtx needle.IExprContext, ctx needle.ISliceExprContext)

type SourceMain

type SourceMain struct {
	Id       int32
	Src      SrcPos
	TreeType TreeType

	ContractDefs []*ContractDef
	FuncDefs     []*FuncDef
}

func NewSourceMain

func NewSourceMain() *SourceMain

type SrcPos

type SrcPos struct {
	Line   int
	Column int
	Start  int
	End    int
	Length int
}

func NewSrcPos

func NewSrcPos(ctx antlr.ParserRuleContext) SrcPos

func NewSrcPosFromSymbol

func NewSrcPosFromSymbol(t antlr.TerminalNode) SrcPos

func (SrcPos) GetText

func (p SrcPos) GetText(input []byte) string

type Statement

type Statement struct {
	*Builder
	Id           int32
	Src          SrcPos
	Block        *Block
	SimpleStmt   *SimpleStmt
	VarDef       *VarDef
	IfStmt       *IfStmt
	WhileStmt    *WhileStmt
	BreakStmt    *BreakStmt
	ContinueStmt *ContinueStmt
	ReturnStmt   *ReturnStmt
	ErrorStmt    *ErrorStmt
}

func NewStatement

func NewStatement(b *Builder) *Statement

func (*Statement) Parse

func (s *Statement) Parse(ctx needle.IStatementContext)

type StatementList

type StatementList struct {
	*Builder
	Id         int32
	Src        SrcPos
	TreeType   TreeType
	Statements []*Statement
}

func NewStatementList

func NewStatementList(b *Builder) *StatementList

func (*StatementList) Parse

type StringLiteral

type StringLiteral struct {
	*Builder
	Id              int32
	Src             SrcPos
	TreeType        TreeType
	Value, HexValue string
}

func NewStringLiteral

func NewStringLiteral(b *Builder) *StringLiteral

func (*StringLiteral) Parse

type TreeType

type TreeType int32
const (
	TreeType_None_Default TreeType = iota
	TreeType_SourceMain
	TreeType_ContractDef
	TreeType_ContractPart
	TreeType_FuncDef
	TreeType_DataDef
	TreeType_DataPart
	TreeType_SettingsDef
	TreeType_Parameter
	TreeType_ParameterList
	TreeType_ReturnParameters
	TreeType_StatementList
	TreeType_Block
	TreeType_Assignment
	TreeType_VarDef
	TreeType_Kind_ControlStmt
	TreeType_IfStmt
	TreeType_ElseStmt
	TreeType_IncDecStmt
	TreeType_WhileStmt
	TreeType_ContinueStmt
	TreeType_BreakStmt
	TreeType_ReturnStmt
	TreeType_FuncSignature
	TreeType_FuncTail
	TreeType_Kind_ErrorStmt
	TreeType_ErrorStmt
	TreeType_ErrWarningStmt
	TreeType_ErrInfoStmt

	TreeType_Kind_Literal
	TreeType_DecimalLiteral
	TreeType_BinaryLiteral
	TreeType_OctalLiteral
	TreeType_HexLiteral
	TreeType_FloatLiteral
	TreeType_InterpretedStringLiteral
	TreeType_RawStringLiteral
	TreeType_BooleanLiteral
	TreeType_NIL
	TreeType_Identifier
	TreeType_DollarIdentifier
	TreeType_AtIdentifier

	TreeType_Kind_Expr
	TreeType_PrimaryExpr
	TreeType_IndexExpr
	TreeType_SliceExpr
	TreeType_MapExpr
	TreeType_ArrayExpr
	TreeType_ContractCall
	TreeType_UnaryOpExpr
	TreeType_MulOpExpr
	TreeType_RelOpExpr
	TreeType_LogicalOpExpr
	TreeType_AddOpExpr
	TreeType_Operand
	TreeType_PairList
	TreeType_Pair
	TreeType_Arguments
	TreeType_ArrayList
)

func (TreeType) String

func (i TreeType) String() string

type UnaryOp

type UnaryOp struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Op        string
	RightExpr *Expr
}

func NewUnaryOp

func NewUnaryOp(b *Builder) *UnaryOp

func (*UnaryOp) Parse

func (u *UnaryOp) Parse(exprCtx needle.IExprContext, ctx needle.IUnary_opContext)

type VarDef

type VarDef struct {
	*Builder
	Id        int32
	Src       SrcPos
	TreeType  TreeType
	Parameter *Parameter
}

func NewVarDef

func NewVarDef(b *Builder) *VarDef

func (*VarDef) Parse

func (v *VarDef) Parse(ctx needle.IVarDefContext)

type WhileStmt

type WhileStmt struct {
	*Builder
	Id       int32
	Src      SrcPos
	TreeType TreeType
	Expr     *Expr
	Block    *Block
}

func NewWhileStmt

func NewWhileStmt(b *Builder) *WhileStmt

func (*WhileStmt) Parse

func (w *WhileStmt) Parse(ctx needle.IWhileStmtContext)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL