runtime

type Addr uint32

type Condition int8

type Context byte

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 global function to get the absolute path
	// of the file where such global was called. If the global 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{})

	// Types returns a Types value that allows to manipulate all the types,
	// including new types defined in the executed code.
	Types() Types
}

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

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

type Format byte

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
	FinalRegs    [][2]int8 // [indirect -> return parameter registers]
	Macro        bool
	Format       Format
	Values       Registers
	FieldIndexes [][]int
	Functions    []*Function
	Predefined   []*PredefinedFunction
	Body         []Instruction
	Text         [][]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 []reflect.Value
}

type Renderer interface {
	Show(env Env, v interface{}, ctx Context)
	Text(env Env, txt []byte, inURL, isSet bool)
	Out() io.Writer
	WithOut(out io.Writer) Renderer
	WithConversion(fromFormat, toFormat Format) Renderer
	Close() error
}

type StackShift [4]int8

type Types interface {

	// New is like reflect.New but if typ is a Scriggo type, the returned
	// Value refers to the underling type of typ.
	New(typ reflect.Type) reflect.Value

	// TypeOf is like reflect.TypeOf but if i has a Scriggo type it returns
	// its Scriggo reflect type instead of the reflect type of the proxy.
	TypeOf(i interface{}) reflect.Type

	// ValueOf is like reflect.ValueOf but if i has a Scriggo type it returns
	// its underling value instead of the reflect value of the proxy.
	ValueOf(i interface{}) reflect.Value
}

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
}