runtime

type Addr uint32

type Condition int8

type DebugInfo struct {
	Position    Position        // position of the instruction in the source code.
	Path        string          // path of the source code where the instruction is located in.
	OperandKind [3]reflect.Kind // kind of operands A, B and C.
	FuncType    reflect.Type    // type of the function that is called; only for call instructions.
}

type Env interface {

	// Context returns the context of the environment.
	Context() context.Context

	// Exit exits the environment with the given status code. Deferred functions
	// are not run.
	Exit(code int)

	// Exited reports whether the environment is exited.
	Exited() bool

	// ExitFunc calls f in its own goroutine after the execution of the
	// environment is terminated.
	ExitFunc(f func())

	// Fatal calls panic() with a FatalError error.
	Fatal(v interface{})

	// FilePath can be called from a builtin function to get the absolute path
	// of the file where such builtin was called. If the builtin function was
	// not called by the main virtual machine goroutine, the returned value is
	// not significant.
	FilePath() string

	// Print calls the print built-in function with args as argument.
	Print(args ...interface{})

	// Println calls the println built-in function with args as argument.
	Println(args ...interface{})
}

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

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

type Function struct {
	Pkg        string
	Name       string
	File       string
	Pos        *Position // position of the function declaration.
	Type       reflect.Type
	Parent     *Function
	VarRefs    []int16
	Types      []reflect.Type
	NumReg     [4]int8
	Constants  Registers
	Functions  []*Function
	Predefined []*PredefinedFunction
	Body       []Instruction
	Data       [][]byte
	DebugInfo  map[Addr]DebugInfo
}

type Instruction struct {
	Op      Operation
	A, B, C int8
}

type Operation int8

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

type Position struct {
	Line   int // line starting from 1
	Column int // column in characters starting from 1
	Start  int // index of the first byte
	End    int // index of the last byte
}

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

type PrintFunc func(interface{})

type Registers struct {
	Int     []int64
	Float   []float64
	String  []string
	General []interface{}
}

type StackShift [4]int8

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

type Wrapper interface {

	// Wrap wraps a value with a Scriggo type putting into a proxy that exposes
	// methods to Go.
	Wrap(reflect.Value) reflect.Value

	// Unwrap unwraps a value that has been read from Go. If the value given as
	// parameter can be unwrapped using the unwrapper's type, the unwrapped
	// value is returned and the method returns true.
	Unwrap(reflect.Value) (reflect.Value, bool)

	// Underlying returns the underlying type of a Scriggo type. Note that the
	// implementation of the reflect.Type returned by Underlying is the
	// implementation of the package 'reflect', so it's safe to pass the
	// returned value to reflect functions and methods as argument.
	Underlying() reflect.Type
}