eval

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

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

 Go to latest Published: Oct 16, 2013 License: BSD-3-Clause Imports: 18 Imported by: 1

Documentation

Overview

Package eval is the beginning of an interpreter for Go. It can run simple Go programs but does not implement interface values or packages.

Index

Constants

This section is empty.

Variables

View Source 
var (
	Uint8Type  = universe.DefineType("uint8", universePos, &uintType{commonType{}, 8, false, "uint8"})
	Uint16Type = universe.DefineType("uint16", universePos, &uintType{commonType{}, 16, false, "uint16"})
	Uint32Type = universe.DefineType("uint32", universePos, &uintType{commonType{}, 32, false, "uint32"})
	Uint64Type = universe.DefineType("uint64", universePos, &uintType{commonType{}, 64, false, "uint64"})

	UintType    = universe.DefineType("uint", universePos, &uintType{commonType{}, 0, false, "uint"})
	UintptrType = universe.DefineType("uintptr", universePos, &uintType{commonType{}, 0, true, "uintptr"})
)
View Source 
var (
	Int8Type  = universe.DefineType("int8", universePos, &intType{commonType{}, 8, "int8"})
	Int16Type = universe.DefineType("int16", universePos, &intType{commonType{}, 16, "int16"})
	Int32Type = universe.DefineType("int32", universePos, &intType{commonType{}, 32, "int32"})
	Int64Type = universe.DefineType("int64", universePos, &intType{commonType{}, 64, "int64"})

	IntType = universe.DefineType("int", universePos, &intType{commonType{}, 0, "int"})
)
View Source 
var (
	Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"})
	Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"})
)
View Source 
var BoolType = universe.DefineType("bool", universePos, &boolType{})
View Source 
var StringType = universe.DefineType("string", universePos, &stringType{})

Functions

func FuncFromNativeTyped 

func FuncFromNativeTyped(fn func(*Thread, []Value, []Value), t interface{}) (*FuncType, FuncValue)

FuncFromNativeTyped is like FuncFromNative, but constructs the function type from a function pointer using reflection. Typically, the type will be given as a nil pointer to a function with the desired signature.

Types

type ArrayType 

type ArrayType struct {
	Len  int64
	Elem Type
	// contains filtered or unexported fields
}

func NewArrayType 

func NewArrayType(len int64, elem Type) *ArrayType

func (ArrayType) Pos 

func (ArrayType) Pos() token.Pos

func (*ArrayType) String 

func (t *ArrayType) String() string

func (*ArrayType) Zero 

func (t *ArrayType) Zero() Value

type ArrayValue 

type ArrayValue interface {
	Value
	// TODO(austin) Get() is here for uniformity, but is
	// completely useless.  If a lot of other types have similarly
	// useless Get methods, just special-case these uses.
	Get(*Thread) ArrayValue
	Elem(*Thread, int64) Value
	// Sub returns an ArrayValue backed by the same array that
	// starts from element i and has length len.
	Sub(i int64, len int64) ArrayValue
}

type BoolValue 

type BoolValue interface {
	Value
	Get(*Thread) bool
	Set(*Thread, bool)
}

type BoundedType 

type BoundedType interface {
	Type
	// contains filtered or unexported methods
}

type Code 

type Code interface {
	// The type of the value Run returns, or nil if Run returns nil.
	Type() Type

	// Run runs the code; if the code is a single expression
	// with a value, it returns the value; otherwise it returns nil.
	Run() (Value, error)
}

type Constant 

type Constant struct {
	ConstPos token.Pos
	Type     Type
	Value    Value
}

func (*Constant) Pos 

func (c *Constant) Pos() token.Pos

type Def 

type Def interface {
	Pos() token.Pos
}

A definition can be a *Variable, *Constant, or Type.

type DivByZeroError 

type DivByZeroError struct{}

func (DivByZeroError) Error 

func (DivByZeroError) Error() string

type FloatValue 

type FloatValue interface {
	Value
	Get(*Thread) float64
	Set(*Thread, float64)
}

type Frame 

type Frame struct {
	Outer *Frame
	Vars  []Value
}

func (*Frame) Get 

func (f *Frame) Get(level int, index int) Value

type Func 

type Func interface {
	NewFrame() *Frame
	Call(*Thread)
}

type FuncDecl 

type FuncDecl struct {
	Type *FuncType
	Name *ast.Ident // nil for function literals
	// InNames will be one longer than Type.In if this function is
	// variadic.
	InNames  []*ast.Ident
	OutNames []*ast.Ident
}

func (*FuncDecl) String 

func (t *FuncDecl) String() string

type FuncType 

type FuncType struct {

	// TODO(austin) Separate receiver Type for methods?
	In       []Type
	Variadic bool
	Out      []Type
	// contains filtered or unexported fields
}

func NewFuncType 

func NewFuncType(in []Type, variadic bool, out []Type) *FuncType

func (FuncType) Pos 

func (FuncType) Pos() token.Pos

func (*FuncType) String 

func (t *FuncType) String() string

func (*FuncType) Zero 

func (t *FuncType) Zero() Value

type FuncValue 

type FuncValue interface {
	Value
	Get(*Thread) Func
	Set(*Thread, Func)
}

func FuncFromNative 

func FuncFromNative(fn func(*Thread, []Value, []Value), t *FuncType) FuncValue

FuncFromNative creates an interpreter function from a native function that takes its in and out arguments as slices of interpreter Value's. While somewhat inconvenient, this avoids value marshalling.

type IMethod 

type IMethod struct {
	Name string
	Type *FuncType
}

type IdealFloatValue 

type IdealFloatValue interface {
	Value
	Get() *big.Rat
}

type IdealIntValue 

type IdealIntValue interface {
	Value
	Get() *big.Int
}

TODO(austin) IdealIntValue and IdealFloatValue should not exist because ideals are not l-values.

type IndexError 

type IndexError struct {
	Idx, Len int64
}

func (IndexError) Error 

func (e IndexError) Error() string

type IntValue 

type IntValue interface {
	Value
	Get(*Thread) int64
	Set(*Thread, int64)
}

type Interface 

type Interface struct {
	Type  Type
	Value Value
}

type InterfaceType 

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

func NewInterfaceType 

func NewInterfaceType(methods []IMethod, embeds []*InterfaceType) *InterfaceType

func (InterfaceType) Pos 

func (InterfaceType) Pos() token.Pos

func (*InterfaceType) String 

func (t *InterfaceType) String() string

func (*InterfaceType) Zero 

func (t *InterfaceType) Zero() Value

type InterfaceValue 

type InterfaceValue interface {
	Value
	Get(*Thread) Interface
	Set(*Thread, Interface)
}

type KeyError 

type KeyError struct {
	Key interface{}
}

func (KeyError) Error 

func (e KeyError) Error() string

type Map 

type Map interface {
	Len(*Thread) int64
	// Retrieve an element from the map, returning nil if it does
	// not exist.
	Elem(t *Thread, key interface{}) Value
	// Set an entry in the map.  If val is nil, delete the entry.
	SetElem(t *Thread, key interface{}, val Value)
	// TODO(austin)  Perhaps there should be an iterator interface instead.
	Iter(func(key interface{}, val Value) bool)
}

type MapType 

type MapType struct {
	Key  Type
	Elem Type
	// contains filtered or unexported fields
}

func NewMapType 

func NewMapType(key Type, elem Type) *MapType

func (MapType) Pos 

func (MapType) Pos() token.Pos

func (*MapType) String 

func (t *MapType) String() string

func (*MapType) Zero 

func (t *MapType) Zero() Value

type MapValue 

type MapValue interface {
	Value
	Get(*Thread) Map
	Set(*Thread, Map)
}

type Method 

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

type MultiType 

type MultiType struct {
	Elems []Type
	// contains filtered or unexported fields
}

MultiType is a special type used for multi-valued expressions, akin to a tuple type. It's not generally accessible within the language.

func NewMultiType 

func NewMultiType(elems []Type) *MultiType

func (MultiType) Pos 

func (MultiType) Pos() token.Pos

func (*MultiType) String 

func (t *MultiType) String() string

func (*MultiType) Zero 

func (t *MultiType) Zero() Value

type NamedType 

type NamedType struct {
	NamePos token.Pos
	Name    string
	// Underlying type.  If incomplete is true, this will be nil.
	// If incomplete is false and this is still nil, then this is
	// a placeholder type representing an error.
	Def Type
	// contains filtered or unexported fields
}

func NewNamedType 

func NewNamedType(name string) *NamedType

TODO(austin) This is temporarily needed by the debugger's remote type parser. This should only be possible with block.DefineType.

func (*NamedType) Complete 

func (t *NamedType) Complete(def Type)

func (*NamedType) Pos 

func (t *NamedType) Pos() token.Pos

func (*NamedType) String 

func (t *NamedType) String() string

func (*NamedType) Zero 

func (t *NamedType) Zero() Value

type NativeFunc 

type NativeFunc struct {
	Fn      func(*Thread, []Value, []Value)
	In, Out int
}

func (*NativeFunc) Call 

func (f *NativeFunc) Call(t *Thread)

func (*NativeFunc) NewFrame 

func (f *NativeFunc) NewFrame() *Frame

type NegativeCapacityError 

type NegativeCapacityError struct {
	Len int64
}

func (NegativeCapacityError) Error 

func (e NegativeCapacityError) Error() string

type NegativeLengthError 

type NegativeLengthError struct {
	Len int64
}

func (NegativeLengthError) Error 

func (e NegativeLengthError) Error() string

type NilPointerError 

type NilPointerError struct{}

func (NilPointerError) Error 

func (NilPointerError) Error() string

type PackageValue 

type PackageValue interface {
	Value
	Get(*Thread) PackageValue
	Ident(*Thread, int) Value
}

type PkgIdent 

type PkgIdent struct {
	PkgPos token.Pos
	// contains filtered or unexported fields
}

func (*PkgIdent) Pos 

func (p *PkgIdent) Pos() token.Pos

type PtrType 

type PtrType struct {
	Elem Type
	// contains filtered or unexported fields
}

func NewPtrType 

func NewPtrType(elem Type) *PtrType

func (PtrType) Pos 

func (PtrType) Pos() token.Pos

func (*PtrType) String 

func (t *PtrType) String() string

func (*PtrType) Zero 

func (t *PtrType) Zero() Value

type PtrValue 

type PtrValue interface {
	Value
	Get(*Thread) Value
	Set(*Thread, Value)
}

type RedefinitionError 

type RedefinitionError struct {
	Name string
	Prev Def
}

func (*RedefinitionError) Error 

func (e *RedefinitionError) Error() string

type Scope 

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

A Scope is the compile-time analogue of a Frame, which captures some subtree of blocks.

func (Scope) ChildScope 

func (b Scope) ChildScope() *Scope

func (Scope) DefineConst 

func (b Scope) DefineConst(name string, pos token.Pos, t Type, v Value) (*Constant, Def)

func (Scope) DefinePackage 

func (b Scope) DefinePackage(id, path string, pos token.Pos) (*PkgIdent, Def)

func (Scope) DefineTemp 

func (b Scope) DefineTemp(t Type) *Variable

func (Scope) DefineType 

func (b Scope) DefineType(name string, pos token.Pos, t Type) Type

func (Scope) DefineVar 

func (b Scope) DefineVar(name string, pos token.Pos, t Type) (*Variable, Def)

func (Scope) Lookup 

func (b Scope) Lookup(name string) (bl *block, level int, def Def)

func (*Scope) NewFrame 

func (s *Scope) NewFrame(outer *Frame) *Frame

type Slice 

type Slice struct {
	Base     ArrayValue
	Len, Cap int64
}

type SliceError 

type SliceError struct {
	Lo, Hi, Cap int64
}

func (SliceError) Error 

func (e SliceError) Error() string

type SliceType 

type SliceType struct {
	Elem Type
	// contains filtered or unexported fields
}

func NewSliceType 

func NewSliceType(elem Type) *SliceType

func (SliceType) Pos 

func (SliceType) Pos() token.Pos

func (*SliceType) String 

func (t *SliceType) String() string

func (*SliceType) Zero 

func (t *SliceType) Zero() Value

type SliceValue 

type SliceValue interface {
	Value
	Get(*Thread) Slice
	Set(*Thread, Slice)
}

type StringValue 

type StringValue interface {
	Value
	Get(*Thread) string
	Set(*Thread, string)
}

type StructField 

type StructField struct {
	Name      string
	Type      Type
	Anonymous bool
}

type StructType 

type StructType struct {
	Elems []StructField
	// contains filtered or unexported fields
}

func NewStructType 

func NewStructType(fields []StructField) *StructType

func (StructType) Pos 

func (StructType) Pos() token.Pos

func (*StructType) String 

func (t *StructType) String() string

func (*StructType) Zero 

func (t *StructType) Zero() Value

type StructValue 

type StructValue interface {
	Value
	// TODO(austin) This is another useless Get()
	Get(*Thread) StructValue
	Field(*Thread, int) Value
}

type Thread 

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

func (*Thread) Abort 

func (t *Thread) Abort(err error)

Abort aborts the thread's current computation, causing the innermost Try to return err.

func (*Thread) Try 

func (t *Thread) Try(f func(t *Thread)) error

Try executes a computation; if the computation Aborts, Try returns the error passed to abort.

type Type 

type Type interface {

	// Zero returns a new zero value of this type.
	Zero() Value
	// String returns the string representation of this type.
	String() string
	// The position where this type was defined, if any.
	Pos() token.Pos
	// contains filtered or unexported methods
}
var EmptyType Type = NewMultiType([]Type{})
var IdealFloatType Type = &idealFloatType{}
var IdealIntType Type = &idealIntType{}

func TypeFromNative 

func TypeFromNative(t reflect.Type) Type

TypeFromNative converts a regular Go type into a the corresponding interpreter Type.

func TypeOfNative 

func TypeOfNative(v interface{}) Type

TypeOfNative returns the interpreter Type of a regular Go value.

type UintValue 

type UintValue interface {
	Value
	Get(*Thread) uint64
	Set(*Thread, uint64)
}

type Value 

type Value interface {
	String() string
	// Assign copies another value into this one.  It should
	// assume that the other value satisfies the same specific
	// value interface (BoolValue, etc.), but must not assume
	// anything about its specific type.
	Assign(t *Thread, o Value)
}

func ToValue 

func ToValue(val interface{}) Value

type Variable 

type Variable struct {
	VarPos token.Pos
	// Index of this variable in the Frame structure
	Index int
	// Static type of this variable
	Type Type
	// Value of this variable.  This is only used by Scope.NewFrame;
	// therefore, it is useful for global scopes but cannot be used
	// in function scopes.
	Init Value
}

func (*Variable) Pos 

func (v *Variable) Pos() token.Pos

type World 

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

func NewWorld 

func NewWorld() *World

func (*World) Compile 

func (w *World) Compile(fset *token.FileSet, text string) (Code, error)

func (*World) CompileDeclList 

func (w *World) CompileDeclList(fset *token.FileSet, decls []ast.Decl) (Code, error)

func (*World) CompileExpr 

func (w *World) CompileExpr(fset *token.FileSet, e ast.Expr) (Code, error)

func (*World) CompilePackage 

func (w *World) CompilePackage(fset *token.FileSet, files []*ast.File, pkgpath string) (Code, error)

func (*World) CompileStmtList 

func (w *World) CompileStmtList(fset *token.FileSet, stmts []ast.Stmt) (Code, error)

func (*World) DefineConst 

func (w *World) DefineConst(name string, t Type, val Value) error

func (*World) DefineVar 

func (w *World) DefineVar(name string, t Type, val Value) (*Variable, 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.