eval

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

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 interface {
	Value
	Get(*Thread) bool
	Set(*Thread, bool)
}

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

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 struct {
	ConstPos token.Pos
	Type     Type
	Value    Value
}

type Def interface {
	Pos() token.Pos
}

type DivByZeroError struct{}

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

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

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

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
}

type FuncType struct {

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

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

type IMethod struct {
	Name string
	Type *FuncType
}

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

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

type IndexError struct {
	Idx, Len int64
}

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

type Interface struct {
	Type  Type
	Value Value
}

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

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

type KeyError struct {
	Key interface{}
}

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 struct {
	Key  Type
	Elem Type
	// contains filtered or unexported fields
}

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

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

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

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
}

type NegativeCapacityError struct {
	Len int64
}

type NegativeLengthError struct {
	Len int64
}

type NilPointerError struct{}

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

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

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

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

type RedefinitionError struct {
	Name string
	Prev Def
}

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

type Slice struct {
	Base     ArrayValue
	Len, Cap int64
}

type SliceError struct {
	Lo, Hi, Cap int64
}

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

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

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

type StructField struct {
	Name      string
	Type      Type
	Anonymous bool
}

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

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

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

type Type interface {

	// Zero returns a new zero value of this type.
	Zero() Value
	// String returns the string representation of this type.
	String() string
	// contains filtered or unexported methods
}

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

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)
}

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
}

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