exec

type AddrOperator Operator

type AddrOperatorInfo struct {
	Lit      string
	InFirst  uint64 // first argument supported types.
	InSecond uint64 // second argument supported types. It may have SameAsFirst flag.
}

type Builder interface {
	// Push instr
	Push(val interface{}) Builder

	// Pop instr
	Pop(n int) Builder

	// BuiltinOp instr
	BuiltinOp(kind Kind, op Operator) Builder

	// Label defines a label to jmp here.
	Label(l Label) Builder

	// Jmp instr
	Jmp(l Label) Builder

	// JmpIf instr
	JmpIf(cond JmpCondFlag, l Label) Builder

	// CaseNE instr
	CaseNE(l Label, arity int) Builder

	// Default instr
	Default() Builder

	// WrapIfErr instr
	WrapIfErr(nret int, l Label) Builder

	// ErrWrap instr
	ErrWrap(nret int, retErr Var, frame *errors.Frame, narg int) Builder

	// ForPhrase instr
	ForPhrase(f ForPhrase, key, val Var, hasExecCtx ...bool) Builder

	// FilterForPhrase instr
	FilterForPhrase(f ForPhrase) Builder

	// EndForPhrase instr
	EndForPhrase(f ForPhrase) Builder

	// ListComprehension instr
	ListComprehension(c Comprehension) Builder

	// MapComprehension instr
	MapComprehension(c Comprehension) Builder

	// EndComprehension instr
	EndComprehension(c Comprehension) Builder

	// Closure instr
	Closure(fun FuncInfo) Builder

	// GoClosure instr
	GoClosure(fun FuncInfo) Builder

	// CallClosure instr
	CallClosure(nexpr, arity int, ellipsis bool) Builder

	// CallGoClosure instr
	CallGoClosure(nexpr, arity int, ellipsis bool) Builder

	// CallFunc instr
	CallFunc(fun FuncInfo, nexpr int) Builder

	// CallFuncv instr
	CallFuncv(fun FuncInfo, nexpr, arity int) Builder

	// CallGoFunc instr
	CallGoFunc(fun GoFuncAddr, nexpr int) Builder

	// CallGoFuncv instr
	CallGoFuncv(fun GoFuncvAddr, nexpr, arity int) Builder

	// GoBuiltin instr
	GoBuiltin(typ reflect.Type, op GoBuiltin) Builder

	// Defer instr
	Defer() Builder

	// Go instr
	Go() Builder

	// DefineFunc instr
	DefineFunc(fun FuncInfo) Builder

	// DefineType name string,reflect.Typeinstr
	DefineType(typ reflect.Type, name string) Builder

	// Return instr
	Return(n int32) Builder

	// Load instr
	Load(idx int32) Builder

	// Addr instr
	Addr(idx int32) Builder

	// Store instr
	Store(idx int32) Builder

	// EndFunc instr
	EndFunc(fun FuncInfo) Builder

	// DefineVar defines variables.
	DefineVar(vars ...Var) Builder

	// InCurrentCtx returns if a variable is in current context or not.
	InCurrentCtx(v Var) bool

	// LoadVar instr
	LoadVar(v Var) Builder

	// StoreVar instr
	StoreVar(v Var) Builder

	// AddrVar instr
	AddrVar(v Var) Builder

	// LoadGoVar instr
	LoadGoVar(addr GoVarAddr) Builder

	// StoreGoVar instr
	StoreGoVar(addr GoVarAddr) Builder

	// AddrGoVar instr
	AddrGoVar(addr GoVarAddr) Builder

	// LoadField instr
	LoadField(typ reflect.Type, index []int) Builder

	// StoreField instr
	StoreField(typ reflect.Type, index []int) Builder

	// AddrField instr
	AddrField(typ reflect.Type, index []int) Builder

	// AddrOp instr
	AddrOp(kind Kind, op AddrOperator) Builder

	// MakeArray instr
	MakeArray(typ reflect.Type, arity int) Builder

	// MakeMap instr
	MakeMap(typ reflect.Type, arity int) Builder

	// Make instr
	Make(typ reflect.Type, arity int) Builder

	// Val instr
	Struct(typ reflect.Type, arity int) Builder

	// Append instr
	Append(typ reflect.Type, arity int) Builder

	// MapIndex instr
	MapIndex(twoValue bool) Builder

	// SetMapIndex instr
	SetMapIndex() Builder

	// Index instr
	Index(idx int) Builder

	// AddrIndex instr
	AddrIndex(idx int) Builder

	// SetIndex instr
	SetIndex(idx int) Builder

	// Slice instr
	Slice(i, j int) Builder

	// Slice3 instr
	Slice3(i, j, k int) Builder

	// TypeCast instr
	TypeCast(from, to reflect.Type) Builder

	// Zero instr
	Zero(typ reflect.Type) Builder

	// New instr
	New(typ reflect.Type) Builder

	// StartStmt emit a `StartStmt` event.
	StartStmt(stmt interface{}) interface{}

	// EndStmt emit a `EndStmt` event.
	EndStmt(stmt, start interface{}) Builder

	// Reserve reserves an instruction.
	Reserve() Reserved

	// ReservedAsPush sets Reserved as Push(v)
	ReservedAsPush(r Reserved, v interface{})

	// ReserveOpLsh reserves an instruction.
	ReserveOpLsh() Reserved

	// ReservedAsOpLsh sets Reserved as OpLsh
	ReservedAsOpLsh(r Reserved, kind Kind, op Operator)

	// GetPackage returns the Go+ package that the Builder works for.
	GetPackage() Package

	// Resolve resolves all unresolved labels/functions/consts/etc.
	Resolve() Code

	// DefineBlock instr
	DefineBlock() Builder

	// EndBlock instr
	EndBlock() Builder

	// Send instr
	Send() Builder

	// Recv instr
	Recv() Builder
}

type Code interface {
	// Len returns code length.
	Len() int
}

type Comprehension interface {
}

type ConstKind = spec.ConstKind

type ForPhrase interface {
}

type FuncInfo interface {
	// Name returns the function name.
	Name() string

	// Type returns type of this function.
	Type() reflect.Type

	// Args sets argument types of a Go+ function.
	Args(in ...reflect.Type) FuncInfo

	// Vargs sets argument types of a variadic Go+ function.
	Vargs(in ...reflect.Type) FuncInfo

	// Return sets return types of a Go+ function.
	Return(out ...Var) FuncInfo

	// NumIn returns a function's input parameter count.
	NumIn() int

	// NumOut returns a function's output parameter count.
	NumOut() int

	// Out returns the type of a function type's i'th output parameter.
	// It panics if i is not in the range [0, NumOut()).
	Out(i int) Var

	// IsVariadic returns if this function is variadic or not.
	IsVariadic() bool

	// IsUnnamedOut returns if function results unnamed or not.
	IsUnnamedOut() bool
}

type GoBuiltin uint

type GoConstInfo struct {
	Pkg   GoPackage
	Name  string
	Kind  ConstKind
	Value interface{}
}

type GoFuncAddr uint32

type GoFuncInfo = GoSymInfo

type GoFuncvAddr uint32

type GoPackage interface {
	PkgPath() string

	// Find lookups a symbol by specified its name.
	Find(name string) (addr uint32, kind SymbolKind, ok bool)

	// FindFunc lookups a Go function by name.
	FindFunc(name string) (addr GoFuncAddr, ok bool)

	// FindFuncv lookups a Go function by name.
	FindFuncv(name string) (addr GoFuncvAddr, ok bool)

	// FindType lookups a Go type by name.
	FindType(name string) (typ reflect.Type, ok bool)

	// FindConst lookups a Go constant by name.
	FindConst(name string) (ci *GoConstInfo, ok bool)
}

type GoSymInfo struct {
	Pkg  GoPackage
	Name string
	This interface{} // address of this symbol
}

type GoVarAddr uint32

type GoVarInfo = GoSymInfo

type JmpCondFlag uint32

type Kind = reflect.Kind

type Label interface {
	// Name returns the label name.
	Name() string
}

type Operator uint

type OperatorInfo struct {
	Lit      string
	InFirst  uint64       // first argument supported types.
	InSecond uint64       // second argument supported types. It may have SameAsFirst flag.
	Out      reflect.Kind // result type. It may be SameAsFirst.
}

type Package interface {
	// NewVar creates a variable instance.
	NewVar(typ reflect.Type, name string) Var

	// NewLabel creates a label object.
	NewLabel(name string) Label

	// NewForPhrase creates a new ForPhrase instance.
	NewForPhrase(in reflect.Type) ForPhrase

	// NewComprehension creates a new Comprehension instance.
	NewComprehension(out reflect.Type) Comprehension

	// NewFunc creates a Go+ function.
	NewFunc(name string, nestDepth uint32, funcType ...int) FuncInfo

	// FindGoPackage lookups a Go package by pkgPath. It returns nil if not found.
	FindGoPackage(pkgPath string) GoPackage

	// GetGoFuncType returns a Go function's type.
	GetGoFuncType(addr GoFuncAddr) reflect.Type

	// GetGoFuncvType returns a Go function's type.
	GetGoFuncvType(addr GoFuncvAddr) reflect.Type

	// GetGoFuncInfo returns a Go function's information.
	GetGoFuncInfo(addr GoFuncAddr) *GoFuncInfo

	// GetGoFuncvInfo returns a Go function's information.
	GetGoFuncvInfo(addr GoFuncvAddr) *GoFuncInfo

	// GetGoVarInfo returns a Go variable's information.
	GetGoVarInfo(addr GoVarAddr) *GoVarInfo
}

type Reserved int

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

type SymbolKind uint32

type Var interface {
	// Name returns the variable name.
	Name() string

	// Type returns the variable type.
	Type() reflect.Type

	// IsUnnamedOut returns if variable unnamed or not.
	IsUnnamedOut() bool
}