5
0
mirror of https://github.com/cwinfo/matterbridge.git synced 2024-11-30 02:41:36 +00:00
matterbridge/vendor/github.com/d5/tengo/runtime/vm.go

1048 lines
22 KiB
Go
Raw Normal View History

package runtime
import (
"fmt"
"sync/atomic"
"github.com/d5/tengo/compiler"
"github.com/d5/tengo/compiler/source"
"github.com/d5/tengo/compiler/token"
"github.com/d5/tengo/objects"
)
const (
// StackSize is the maximum stack size.
StackSize = 2048
// GlobalsSize is the maximum number of global variables.
GlobalsSize = 1024
// MaxFrames is the maximum number of function frames.
MaxFrames = 1024
)
// VM is a virtual machine that executes the bytecode compiled by Compiler.
type VM struct {
constants []objects.Object
stack [StackSize]objects.Object
sp int
globals []objects.Object
fileSet *source.FileSet
frames [MaxFrames]Frame
framesIndex int
curFrame *Frame
curInsts []byte
ip int
aborting int64
maxAllocs int64
allocs int64
err error
}
// NewVM creates a VM.
func NewVM(bytecode *compiler.Bytecode, globals []objects.Object, maxAllocs int64) *VM {
if globals == nil {
globals = make([]objects.Object, GlobalsSize)
}
v := &VM{
constants: bytecode.Constants,
sp: 0,
globals: globals,
fileSet: bytecode.FileSet,
framesIndex: 1,
ip: -1,
maxAllocs: maxAllocs,
2019-03-05 22:08:54 +00:00
}
v.frames[0].fn = bytecode.MainFunction
v.frames[0].ip = -1
v.curFrame = &v.frames[0]
v.curInsts = v.curFrame.fn.Instructions
return v
}
// Abort aborts the execution.
func (v *VM) Abort() {
atomic.StoreInt64(&v.aborting, 1)
}
// Run starts the execution.
func (v *VM) Run() (err error) {
// reset VM states
v.sp = 0
v.curFrame = &(v.frames[0])
v.curInsts = v.curFrame.fn.Instructions
v.framesIndex = 1
v.ip = -1
v.allocs = v.maxAllocs + 1
2019-03-05 22:08:54 +00:00
v.run()
atomic.StoreInt64(&v.aborting, 0)
2019-03-05 22:08:54 +00:00
err = v.err
if err != nil {
filePos := v.fileSet.Position(v.curFrame.fn.SourcePos(v.ip - 1))
2019-03-05 22:08:54 +00:00
err = fmt.Errorf("Runtime Error: %s\n\tat %s", err.Error(), filePos)
for v.framesIndex > 1 {
v.framesIndex--
v.curFrame = &v.frames[v.framesIndex-1]
filePos = v.fileSet.Position(v.curFrame.fn.SourcePos(v.curFrame.ip - 1))
2019-03-05 22:08:54 +00:00
err = fmt.Errorf("%s\n\tat %s", err.Error(), filePos)
}
return err
}
return nil
}
2019-03-05 22:08:54 +00:00
func (v *VM) run() {
defer func() {
if r := recover(); r != nil {
if v.sp >= StackSize || v.framesIndex >= MaxFrames {
v.err = ErrStackOverflow
return
}
if v.ip < len(v.curInsts)-1 {
if err, ok := r.(error); ok {
v.err = err
} else {
v.err = fmt.Errorf("panic: %v", r)
}
}
}
}()
for atomic.LoadInt64(&v.aborting) == 0 {
v.ip++
switch v.curInsts[v.ip] {
case compiler.OpConstant:
v.ip += 2
cidx := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
v.stack[v.sp] = v.constants[cidx]
v.sp++
case compiler.OpNull:
v.stack[v.sp] = objects.UndefinedValue
v.sp++
case compiler.OpBinaryOp:
v.ip++
right := v.stack[v.sp-1]
left := v.stack[v.sp-2]
tok := token.Token(v.curInsts[v.ip])
res, e := left.BinaryOp(tok, right)
if e != nil {
v.sp -= 2
if e == objects.ErrInvalidOperator {
v.err = fmt.Errorf("invalid operation: %s %s %s",
left.TypeName(), tok.String(), right.TypeName())
return
}
v.err = e
return
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
return
}
v.stack[v.sp-2] = res
v.sp--
case compiler.OpEqual:
right := v.stack[v.sp-1]
left := v.stack[v.sp-2]
v.sp -= 2
if left.Equals(right) {
v.stack[v.sp] = objects.TrueValue
} else {
v.stack[v.sp] = objects.FalseValue
}
v.sp++
case compiler.OpNotEqual:
right := v.stack[v.sp-1]
left := v.stack[v.sp-2]
v.sp -= 2
if left.Equals(right) {
v.stack[v.sp] = objects.FalseValue
} else {
v.stack[v.sp] = objects.TrueValue
}
v.sp++
case compiler.OpPop:
v.sp--
case compiler.OpTrue:
v.stack[v.sp] = objects.TrueValue
v.sp++
case compiler.OpFalse:
v.stack[v.sp] = objects.FalseValue
v.sp++
case compiler.OpLNot:
operand := v.stack[v.sp-1]
v.sp--
if operand.IsFalsy() {
v.stack[v.sp] = objects.TrueValue
} else {
v.stack[v.sp] = objects.FalseValue
}
v.sp++
case compiler.OpBComplement:
operand := v.stack[v.sp-1]
v.sp--
switch x := operand.(type) {
case *objects.Int:
var res objects.Object = &objects.Int{Value: ^x.Value}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = res
v.sp++
default:
v.err = fmt.Errorf("invalid operation: ^%s", operand.TypeName())
2019-03-05 22:08:54 +00:00
return
}
case compiler.OpMinus:
operand := v.stack[v.sp-1]
v.sp--
switch x := operand.(type) {
case *objects.Int:
var res objects.Object = &objects.Int{Value: -x.Value}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = res
v.sp++
case *objects.Float:
var res objects.Object = &objects.Float{Value: -x.Value}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = res
v.sp++
default:
v.err = fmt.Errorf("invalid operation: -%s", operand.TypeName())
2019-03-05 22:08:54 +00:00
return
}
case compiler.OpJumpFalsy:
v.ip += 2
v.sp--
if v.stack[v.sp].IsFalsy() {
pos := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
v.ip = pos - 1
}
case compiler.OpAndJump:
v.ip += 2
if v.stack[v.sp-1].IsFalsy() {
pos := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
v.ip = pos - 1
} else {
v.sp--
}
case compiler.OpOrJump:
v.ip += 2
if v.stack[v.sp-1].IsFalsy() {
v.sp--
} else {
pos := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
v.ip = pos - 1
}
case compiler.OpJump:
pos := int(v.curInsts[v.ip+2]) | int(v.curInsts[v.ip+1])<<8
v.ip = pos - 1
case compiler.OpSetGlobal:
v.ip += 2
v.sp--
globalIndex := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
v.globals[globalIndex] = v.stack[v.sp]
case compiler.OpSetSelGlobal:
v.ip += 3
globalIndex := int(v.curInsts[v.ip-1]) | int(v.curInsts[v.ip-2])<<8
numSelectors := int(v.curInsts[v.ip])
// selectors and RHS value
selectors := make([]objects.Object, numSelectors)
for i := 0; i < numSelectors; i++ {
selectors[i] = v.stack[v.sp-numSelectors+i]
}
val := v.stack[v.sp-numSelectors-1]
v.sp -= numSelectors + 1
if e := indexAssign(v.globals[globalIndex], val, selectors); e != nil {
2019-03-05 22:08:54 +00:00
v.err = e
return
}
case compiler.OpGetGlobal:
v.ip += 2
globalIndex := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
val := v.globals[globalIndex]
v.stack[v.sp] = val
v.sp++
case compiler.OpArray:
v.ip += 2
numElements := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
var elements []objects.Object
for i := v.sp - numElements; i < v.sp; i++ {
elements = append(elements, v.stack[i])
}
v.sp -= numElements
var arr objects.Object = &objects.Array{Value: elements}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = arr
v.sp++
case compiler.OpMap:
v.ip += 2
numElements := int(v.curInsts[v.ip]) | int(v.curInsts[v.ip-1])<<8
kv := make(map[string]objects.Object)
for i := v.sp - numElements; i < v.sp; i += 2 {
key := v.stack[i]
value := v.stack[i+1]
kv[key.(*objects.String).Value] = value
}
v.sp -= numElements
var m objects.Object = &objects.Map{Value: kv}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = m
v.sp++
case compiler.OpError:
value := v.stack[v.sp-1]
var e objects.Object = &objects.Error{
Value: value,
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
return
}
v.stack[v.sp-1] = e
case compiler.OpImmutable:
value := v.stack[v.sp-1]
switch value := value.(type) {
case *objects.Array:
var immutableArray objects.Object = &objects.ImmutableArray{
Value: value.Value,
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
return
}
v.stack[v.sp-1] = immutableArray
case *objects.Map:
var immutableMap objects.Object = &objects.ImmutableMap{
Value: value.Value,
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
return
}
v.stack[v.sp-1] = immutableMap
}
case compiler.OpIndex:
index := v.stack[v.sp-1]
left := v.stack[v.sp-2]
v.sp -= 2
switch left := left.(type) {
case objects.Indexable:
val, e := left.IndexGet(index)
if e != nil {
if e == objects.ErrInvalidIndexType {
v.err = fmt.Errorf("invalid index type: %s", index.TypeName())
2019-03-05 22:08:54 +00:00
return
}
2019-03-05 22:08:54 +00:00
v.err = e
return
}
if val == nil {
val = objects.UndefinedValue
}
v.stack[v.sp] = val
v.sp++
case *objects.Error: // e.value
key, ok := index.(*objects.String)
if !ok || key.Value != "value" {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid index on error")
return
}
v.stack[v.sp] = left.Value
v.sp++
default:
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("not indexable: %s", left.TypeName())
return
}
case compiler.OpSliceIndex:
high := v.stack[v.sp-1]
low := v.stack[v.sp-2]
left := v.stack[v.sp-3]
v.sp -= 3
var lowIdx int64
if low != objects.UndefinedValue {
if low, ok := low.(*objects.Int); ok {
lowIdx = low.Value
} else {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index type: %s", low.TypeName())
return
}
}
switch left := left.(type) {
case *objects.Array:
numElements := int64(len(left.Value))
var highIdx int64
if high == objects.UndefinedValue {
highIdx = numElements
} else if high, ok := high.(*objects.Int); ok {
highIdx = high.Value
} else {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index type: %s", high.TypeName())
return
}
if lowIdx > highIdx {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index: %d > %d", lowIdx, highIdx)
return
}
if lowIdx < 0 {
lowIdx = 0
} else if lowIdx > numElements {
lowIdx = numElements
}
if highIdx < 0 {
highIdx = 0
} else if highIdx > numElements {
highIdx = numElements
}
var val objects.Object = &objects.Array{Value: left.Value[lowIdx:highIdx]}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = val
v.sp++
case *objects.ImmutableArray:
numElements := int64(len(left.Value))
var highIdx int64
if high == objects.UndefinedValue {
highIdx = numElements
} else if high, ok := high.(*objects.Int); ok {
highIdx = high.Value
} else {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index type: %s", high.TypeName())
return
}
if lowIdx > highIdx {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index: %d > %d", lowIdx, highIdx)
return
}
if lowIdx < 0 {
lowIdx = 0
} else if lowIdx > numElements {
lowIdx = numElements
}
if highIdx < 0 {
highIdx = 0
} else if highIdx > numElements {
highIdx = numElements
}
var val objects.Object = &objects.Array{Value: left.Value[lowIdx:highIdx]}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = val
v.sp++
case *objects.String:
numElements := int64(len(left.Value))
var highIdx int64
if high == objects.UndefinedValue {
highIdx = numElements
} else if high, ok := high.(*objects.Int); ok {
highIdx = high.Value
} else {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index type: %s", high.TypeName())
return
}
if lowIdx > highIdx {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index: %d > %d", lowIdx, highIdx)
return
}
if lowIdx < 0 {
lowIdx = 0
} else if lowIdx > numElements {
lowIdx = numElements
}
if highIdx < 0 {
highIdx = 0
} else if highIdx > numElements {
highIdx = numElements
}
var val objects.Object = &objects.String{Value: left.Value[lowIdx:highIdx]}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = val
v.sp++
case *objects.Bytes:
numElements := int64(len(left.Value))
var highIdx int64
if high == objects.UndefinedValue {
highIdx = numElements
} else if high, ok := high.(*objects.Int); ok {
highIdx = high.Value
} else {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index type: %s", high.TypeName())
return
}
if lowIdx > highIdx {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid slice index: %d > %d", lowIdx, highIdx)
return
}
if lowIdx < 0 {
lowIdx = 0
} else if lowIdx > numElements {
lowIdx = numElements
}
if highIdx < 0 {
highIdx = 0
} else if highIdx > numElements {
highIdx = numElements
}
var val objects.Object = &objects.Bytes{Value: left.Value[lowIdx:highIdx]}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = val
v.sp++
}
case compiler.OpCall:
numArgs := int(v.curInsts[v.ip+1])
v.ip++
value := v.stack[v.sp-1-numArgs]
switch callee := value.(type) {
case *objects.Closure:
if numArgs != callee.Fn.NumParameters {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("wrong number of arguments: want=%d, got=%d",
callee.Fn.NumParameters, numArgs)
2019-03-05 22:08:54 +00:00
return
}
// test if it's tail-call
if callee.Fn == v.curFrame.fn { // recursion
nextOp := v.curInsts[v.ip+1]
if nextOp == compiler.OpReturn ||
(nextOp == compiler.OpPop && compiler.OpReturn == v.curInsts[v.ip+2]) {
for p := 0; p < numArgs; p++ {
v.stack[v.curFrame.basePointer+p] = v.stack[v.sp-numArgs+p]
}
v.sp -= numArgs + 1
v.ip = -1 // reset IP to beginning of the frame
continue
}
}
// update call frame
v.curFrame.ip = v.ip // store current ip before call
v.curFrame = &(v.frames[v.framesIndex])
v.curFrame.fn = callee.Fn
v.curFrame.freeVars = callee.Free
v.curFrame.basePointer = v.sp - numArgs
v.curInsts = callee.Fn.Instructions
v.ip = -1
v.framesIndex++
v.sp = v.sp - numArgs + callee.Fn.NumLocals
case *objects.CompiledFunction:
if numArgs != callee.NumParameters {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("wrong number of arguments: want=%d, got=%d",
callee.NumParameters, numArgs)
2019-03-05 22:08:54 +00:00
return
}
// test if it's tail-call
if callee == v.curFrame.fn { // recursion
nextOp := v.curInsts[v.ip+1]
if nextOp == compiler.OpReturn ||
(nextOp == compiler.OpPop && compiler.OpReturn == v.curInsts[v.ip+2]) {
for p := 0; p < numArgs; p++ {
v.stack[v.curFrame.basePointer+p] = v.stack[v.sp-numArgs+p]
}
v.sp -= numArgs + 1
v.ip = -1 // reset IP to beginning of the frame
continue
}
}
// update call frame
v.curFrame.ip = v.ip // store current ip before call
v.curFrame = &(v.frames[v.framesIndex])
v.curFrame.fn = callee
v.curFrame.freeVars = nil
v.curFrame.basePointer = v.sp - numArgs
v.curInsts = callee.Instructions
v.ip = -1
v.framesIndex++
v.sp = v.sp - numArgs + callee.NumLocals
case objects.Callable:
var args []objects.Object
for _, arg := range v.stack[v.sp-numArgs : v.sp] {
args = append(args, arg)
}
ret, e := callee.Call(args...)
v.sp -= numArgs + 1
// runtime error
if e != nil {
if e == objects.ErrWrongNumArguments {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("wrong number of arguments in call to '%s'",
value.TypeName())
2019-03-05 22:08:54 +00:00
return
}
if e, ok := e.(objects.ErrInvalidArgumentType); ok {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("invalid type for argument '%s' in call to '%s': expected %s, found %s",
e.Name, value.TypeName(), e.Expected, e.Found)
2019-03-05 22:08:54 +00:00
return
}
2019-03-05 22:08:54 +00:00
v.err = e
return
}
// nil return -> undefined
if ret == nil {
ret = objects.UndefinedValue
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = ret
v.sp++
default:
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("not callable: %s", callee.TypeName())
return
}
case compiler.OpReturn:
v.ip++
var retVal objects.Object
if int(v.curInsts[v.ip]) == 1 {
retVal = v.stack[v.sp-1]
} else {
retVal = objects.UndefinedValue
}
//v.sp--
v.framesIndex--
v.curFrame = &v.frames[v.framesIndex-1]
v.curInsts = v.curFrame.fn.Instructions
v.ip = v.curFrame.ip
//v.sp = lastFrame.basePointer - 1
v.sp = v.frames[v.framesIndex].basePointer
// skip stack overflow check because (newSP) <= (oldSP)
v.stack[v.sp-1] = retVal
//v.sp++
case compiler.OpDefineLocal:
v.ip++
localIndex := int(v.curInsts[v.ip])
sp := v.curFrame.basePointer + localIndex
// local variables can be mutated by other actions
// so always store the copy of popped value
val := v.stack[v.sp-1]
v.sp--
v.stack[sp] = val
case compiler.OpSetLocal:
localIndex := int(v.curInsts[v.ip+1])
v.ip++
sp := v.curFrame.basePointer + localIndex
// update pointee of v.stack[sp] instead of replacing the pointer itself.
// this is needed because there can be free variables referencing the same local variables.
val := v.stack[v.sp-1]
v.sp--
if obj, ok := v.stack[sp].(*objects.ObjectPtr); ok {
*obj.Value = val
val = obj
}
v.stack[sp] = val // also use a copy of popped value
case compiler.OpSetSelLocal:
localIndex := int(v.curInsts[v.ip+1])
numSelectors := int(v.curInsts[v.ip+2])
v.ip += 2
// selectors and RHS value
selectors := make([]objects.Object, numSelectors)
for i := 0; i < numSelectors; i++ {
selectors[i] = v.stack[v.sp-numSelectors+i]
}
val := v.stack[v.sp-numSelectors-1]
v.sp -= numSelectors + 1
sp := v.curFrame.basePointer + localIndex
if e := indexAssign(v.stack[sp], val, selectors); e != nil {
2019-03-05 22:08:54 +00:00
v.err = e
return
}
case compiler.OpGetLocal:
v.ip++
localIndex := int(v.curInsts[v.ip])
val := v.stack[v.curFrame.basePointer+localIndex]
if obj, ok := val.(*objects.ObjectPtr); ok {
val = *obj.Value
}
v.stack[v.sp] = val
v.sp++
case compiler.OpGetBuiltin:
v.ip++
builtinIndex := int(v.curInsts[v.ip])
v.stack[v.sp] = objects.Builtins[builtinIndex]
v.sp++
case compiler.OpClosure:
v.ip += 3
constIndex := int(v.curInsts[v.ip-1]) | int(v.curInsts[v.ip-2])<<8
numFree := int(v.curInsts[v.ip])
fn, ok := v.constants[constIndex].(*objects.CompiledFunction)
if !ok {
2019-03-05 22:08:54 +00:00
v.err = fmt.Errorf("not function: %s", fn.TypeName())
return
}
free := make([]*objects.ObjectPtr, numFree)
for i := 0; i < numFree; i++ {
switch freeVar := (v.stack[v.sp-numFree+i]).(type) {
case *objects.ObjectPtr:
free[i] = freeVar
default:
free[i] = &objects.ObjectPtr{Value: &v.stack[v.sp-numFree+i]}
}
}
v.sp -= numFree
var cl = &objects.Closure{
Fn: fn,
Free: free,
}
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
return
}
v.stack[v.sp] = cl
v.sp++
case compiler.OpGetFreePtr:
v.ip++
freeIndex := int(v.curInsts[v.ip])
val := v.curFrame.freeVars[freeIndex]
v.stack[v.sp] = val
v.sp++
case compiler.OpGetFree:
v.ip++
freeIndex := int(v.curInsts[v.ip])
val := *v.curFrame.freeVars[freeIndex].Value
v.stack[v.sp] = val
v.sp++
case compiler.OpSetFree:
v.ip++
freeIndex := int(v.curInsts[v.ip])
*v.curFrame.freeVars[freeIndex].Value = v.stack[v.sp-1]
v.sp--
case compiler.OpGetLocalPtr:
v.ip++
localIndex := int(v.curInsts[v.ip])
sp := v.curFrame.basePointer + localIndex
val := v.stack[sp]
var freeVar *objects.ObjectPtr
if obj, ok := val.(*objects.ObjectPtr); ok {
freeVar = obj
} else {
freeVar = &objects.ObjectPtr{Value: &val}
v.stack[sp] = freeVar
}
v.stack[v.sp] = freeVar
v.sp++
case compiler.OpSetSelFree:
v.ip += 2
freeIndex := int(v.curInsts[v.ip-1])
numSelectors := int(v.curInsts[v.ip])
// selectors and RHS value
selectors := make([]objects.Object, numSelectors)
for i := 0; i < numSelectors; i++ {
selectors[i] = v.stack[v.sp-numSelectors+i]
}
val := v.stack[v.sp-numSelectors-1]
v.sp -= numSelectors + 1
if e := indexAssign(*v.curFrame.freeVars[freeIndex].Value, val, selectors); e != nil {
2019-03-05 22:08:54 +00:00
v.err = e
return
}
case compiler.OpIteratorInit:
var iterator objects.Object
dst := v.stack[v.sp-1]
v.sp--
iterable, ok := dst.(objects.Iterable)
if !ok {
v.err = fmt.Errorf("not iterable: %s", dst.TypeName())
2019-03-05 22:08:54 +00:00
return
}
iterator = iterable.Iterate()
v.allocs--
if v.allocs == 0 {
v.err = ErrObjectAllocLimit
2019-03-05 22:08:54 +00:00
return
}
v.stack[v.sp] = iterator
v.sp++
case compiler.OpIteratorNext:
iterator := v.stack[v.sp-1]
v.sp--
hasMore := iterator.(objects.Iterator).Next()
if hasMore {
v.stack[v.sp] = objects.TrueValue
} else {
v.stack[v.sp] = objects.FalseValue
}
v.sp++
case compiler.OpIteratorKey:
iterator := v.stack[v.sp-1]
v.sp--
val := iterator.(objects.Iterator).Key()
v.stack[v.sp] = val
v.sp++
case compiler.OpIteratorValue:
iterator := v.stack[v.sp-1]
v.sp--
val := iterator.(objects.Iterator).Value()
v.stack[v.sp] = val
v.sp++
default:
v.err = fmt.Errorf("unknown opcode: %d", v.curInsts[v.ip])
return
}
}
}
// IsStackEmpty tests if the stack is empty or not.
func (v *VM) IsStackEmpty() bool {
return v.sp == 0
}
func indexAssign(dst, src objects.Object, selectors []objects.Object) error {
numSel := len(selectors)
for sidx := numSel - 1; sidx > 0; sidx-- {
indexable, ok := dst.(objects.Indexable)
if !ok {
return fmt.Errorf("not indexable: %s", dst.TypeName())
}
next, err := indexable.IndexGet(selectors[sidx])
if err != nil {
if err == objects.ErrInvalidIndexType {
return fmt.Errorf("invalid index type: %s", selectors[sidx].TypeName())
}
return err
}
dst = next
}
indexAssignable, ok := dst.(objects.IndexAssignable)
if !ok {
return fmt.Errorf("not index-assignable: %s", dst.TypeName())
}
if err := indexAssignable.IndexSet(selectors[0], src); err != nil {
if err == objects.ErrInvalidIndexValueType {
return fmt.Errorf("invaid index value type: %s", src.TypeName())
}
return err
}
return nil
}