vm.go

package mruby

import (
	"encoding/binary"
	"errors"
	"fmt"

	"github.com/elct9620/mruby-go/insn"
	"github.com/elct9620/mruby-go/op"
	"github.com/elct9620/mruby-go/stack"
)

var (
	ErrIRepNotFound               = errors.New("irep not found")
	ErrNotPrimitiveTypeComparison = errors.New("not primitive type comparison")
)

func (mrb *State) TopRun(proc RProc, self Value) (Value, error) {
	if !mrb.context.IsTop() {
		mrb.callinfoPush(0, 0, mrb.ObjectClass, proc, nil, 0, 0)
	}

	return mrb.VmRun(proc, self)
}

func (mrb *State) VmRun(proc RProc, self Value) (Value, error) {
	irep, ok := proc.Body().(*insn.Representation)
	if !ok {
		return nil, ErrIRepNotFound
	}

	if mrb.context.stack == nil {
		mrb.context.stack = stack.New[Value](StackInitSize)
	}

	mrb.context.Set(0, mrb.topSelf)

	return mrb.VmExec(proc, irep.Sequence().Clone())
}

func (mrb *State) VmExec(proc RProc, code *insn.Sequence) (ret Value, err error) {
	defer func() {
		if r := recover(); r != nil {
			ret = nil

			switch v := r.(type) {
			case RException:
				ret = v
			case error:
				err = v
			}
		}
	}()

	rep, ok := proc.Body().(*insn.Representation)
	if !ok {
		panic(ErrIRepNotFound)
	}

	ctx := mrb.context

	for {
		opCode := code.Operation()

		switch opCode {
		case op.Nop:
			ctx.SetSequenceCursor(code.Cursor())
			continue
		case op.Move:
			a := code.ReadB()
			b := code.ReadB()

			ctx.SetSequenceCursor(code.Cursor())
			ctx.Set(int(a), ctx.Get(int(b)))
		case op.LoadL:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), rep.PoolValue(b))
		case op.LoadI:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), int(b))
		case op.LoadINeg:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), -int(b))
		case op.LoadI__1, op.LoadI_0, op.LoadI_1, op.LoadI_2, op.LoadI_3, op.LoadI_4, op.LoadI_5, op.LoadI_6, op.LoadI_7:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), int(opCode)-int(op.LoadI_0))
		case op.LoadT, op.LoadF:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), opCode == op.LoadT)
		case op.LoadI16:
			a := code.ReadB()
			b := code.ReadS()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), int(int16(binary.BigEndian.Uint16(b))))
		case op.LoadI32:
			a := code.ReadB()
			b := code.ReadS()
			c := code.ReadS()
			ctx.SetSequenceCursor(code.Cursor())

			v := append(b, c...)
			ctx.Set(int(a), int(int32(binary.BigEndian.Uint32(v))))
		case op.LoadSym:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), rep.Symbol(b))
		case op.LoadNil:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), nil)
		case op.GetConst:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), mrb.VmGetConst(rep.Symbol(b)))
		case op.SetConst:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			mrb.VmSetConst(rep.Symbol(b), ctx.Get(int(a)))
		case op.Jmp:
			a := code.ReadS()
			ctx.SetSequenceCursor(code.Cursor())

			offset := int(int16(binary.BigEndian.Uint16(a)))
			code.Seek(code.Cursor() + offset)
		case op.JmpNot:
			a := code.ReadB()
			b := code.ReadS()
			ctx.SetSequenceCursor(code.Cursor())

			val := ctx.Get(int(a))

			if !Test(val) {
				offset := int(int16(binary.BigEndian.Uint16(b)))
				code.Seek(code.Cursor() + offset)
			}
		case op.SelfSend, op.Send, op.SendB:
			a := code.ReadB()
			b := code.ReadB()
			c := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			if opCode == op.SelfSend {
				ctx.Set(int(a), ctx.Get(0))
				opCode = op.Send //nolint:ineffassign
			}

			mid := rep.Symbol(b)

			ci := mrb.callinfoPush(int(a), 0, nil, nil, nil, mid, uint16(c))
			recv := ctx.Get(0)

			ci.targetClass = mrb.Class(recv)

			method := mrb.VmFindMethod(recv, ci.targetClass, ci.methodId)

			if method == nil {
				ctx.Set(int(a), nil)
				mrb.callinfoPop()

				mrb.Raisef(nil, "undefined method '%s' for %s", mrb.SymbolName(mid), mrb.ClassName(ci.targetClass))
			}

			if method.IsProc() {
				proc := method.Proc()
				ci.proc = proc

				if !proc.IsGoFunction() {
					nirep := proc.Body().(*insn.Representation)

					rep = nirep
					code = nirep.Sequence().Clone()

					continue
				}
			}

			ctx.Set(0, method.Call(mrb, recv))
			mrb.callinfoPop()
		case op.Enter:
			a := code.ReadW()
			a = append([]byte{0x00}, a...)
			aspec := int(int32(binary.BigEndian.Uint32(a)))

			ci := ctx.GetCallinfo()
			argc := ci.numArgs

			req := AspecReq(aspec)
			opt := AspecOpt(aspec)
			rest := AspecRest(aspec)

			if (aspec & ^0x7c0001) == 0 {
				if argc != req {
					mrb.Raisef(nil, "wrong number of arguments (given %d, expected %d)", argc, req)
				}
			}

			if rest > 0 {
				values := make([]Value, 0)
				argv := mrb.GetArgv()
				for i := req + opt; i < len(argv); i++ {
					values = append(values, argv[i])
				}

				ctx.Set(req+opt+1, values)
			}

			ctx.SetSequenceCursor(code.Cursor())
		case op.EQ:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			val1 := ctx.Get(int(a))
			val2 := ctx.Get(int(a) + 1)

			ctx.Set(int(a), val1 == val2)
		case op.LT, op.LE, op.GT, op.GE:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			res, err := opCompare(ctx, int(a), int(a)+1, opCode)
			if err != nil {
				panic(err)
			}

			ctx.Set(int(a), res)
		case op.Array:
			a := code.ReadB()
			b := code.ReadB()

			begin := int(a)
			end := int(a) + int(b) - 1

			ctx.Set(int(a), ctx.Slice(begin, end))
		case op.String:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), rep.PoolValue(b))
		case op.Return:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ret := ctx.Get(int(a))
			if ctx.IsTop() {
				ctx.Set(int(rep.Locals()), ret)
				goto Stop
			}

			ctx.Set(0, ret)
			ci := mrb.callinfoPop()
			proc := ci.Proc()
			nirep, ok := proc.Body().(*insn.Representation)
			if !ok {
				panic(ErrIRepNotFound)
			}

			rep = nirep
			code = rep.Sequence().Clone()
			code.Seek(ci.GetSequnceCursor())
		case op.StrCat:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), fmt.Sprintf("%v%v", ctx.Get(int(a)), ctx.Get(int(a)+1)))
		case op.Hash:
			a := code.ReadB()
			b := code.ReadB()

			hash := make(map[Value]Value, int(b))
			limit := int(a) + int(b)*2

			for i := int(a); i < limit; i += 2 {
				key := ctx.Get(i)
				val := ctx.Get(i + 1)

				hash[key] = val
			}

			ctx.Set(int(a), hash)
		case op.Class:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			base := ctx.Get(int(a))
			super := ctx.Get(int(a) + 1)
			id := rep.Symbol(b)

			if base == nil {
				base = mrb.ObjectClass
			}

			class, err := mrb.vmDefineClass(base, super, id)
			if err != nil {
				panic(err)
			}

			ctx.Set(int(a), NewObjectValue(class))
		case op.Module:
			a := code.ReadB()
			b := code.ReadB()

			id := rep.Symbol(b)
			base, ok := ctx.Get(int(a)).(RClass)
			if !ok {
				base = mrb.ObjectClass
			}

			module := mrb.vmDefineModule(base, id)
			ctx.Set(int(a), NewObjectValue(module))
		case op.Method:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			nirep := rep.Representation(b)
			nproc := mrb.procNew(nirep)

			ctx.Set(int(a), NewObjectValue(nproc))
		case op.Exec:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			recv, ok := ctx.Get(int(a)).(RClass)
			if !ok {
				mrb.Raisef(nil, "not a class: %v", ctx.Get(int(a)))
			}

			nirep := rep.Representation(b)
			proc := mrb.procNew(nirep)

			mrb.callinfoPush(int(a), 0, recv, proc, nil, 0, 0)

			rep = nirep
			code = rep.Sequence().Clone()
		case op.Def:
			a := code.ReadB()
			b := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			targetClass := ctx.Get(int(a)).(RClass)
			methodProc := ctx.Get(int(a) + 1).(RProc)
			mid := rep.Symbol(b)

			method := newMethodFromProc(methodProc)
			mrb.defineMethodRaw(targetClass, mid, method)

			ctx.Set(int(a), mid)
		case op.TClass:
			a := code.ReadB()
			ctx.SetSequenceCursor(code.Cursor())

			ctx.Set(int(a), mrb.context.GetCallinfo().TargetClass())
		case op.Stop:
			ctx.SetSequenceCursor(code.Cursor())
			goto Stop
		default:
			panic(fmt.Errorf("opcode %d not implemented", opCode))
		}
	}

Stop:
	return ctx.Get(int(rep.Locals())), nil
}

func (state *State) callinfoPush(pushStack int, cci uint8, targetClass RClass, proc RProc, block RProc, mid Symbol, argc uint16) *callinfo {
	ctx := state.context
	prevCi := ctx.GetCallinfo()

	if prevCi == nil {
		prevCi = &callinfo{}
	}

	callinfo := &callinfo{
		methodId:    mid,
		stackOffset: prevCi.stackOffset + pushStack,
		numArgs:     int(argc & 0xf),
		numKeywords: int((argc >> 4) & 0xf),
		targetClass: targetClass,
		proc:        proc,
	}
	ctx.callinfo.Push(callinfo)

	return callinfo
}

func (state *State) callinfoPop() *callinfo {
	ctx := state.context
	ctx.callinfo.Pop()

	return ctx.GetCallinfo()
}

func opCompare(ctx *context, a int, b int, code op.Code) (bool, error) {
	val1, ok := toFloat64(ctx.Get(a))
	if !ok {
		return false, ErrNotPrimitiveTypeComparison
	}

	val2, ok := toFloat64(ctx.Get(b))
	if !ok {
		return false, ErrNotPrimitiveTypeComparison
	}

	switch code {
	case op.LT:
		return val1 < val2, nil
	case op.LE:
		return val1 <= val2, nil
	case op.GT:
		return val1 > val2, nil
	case op.GE:
		return val1 >= val2, nil
	}

	return false, ErrNotPrimitiveTypeComparison
}

func toFloat64(val Value) (float64, bool) {
	switch v := val.(type) {
	case int:
		return float64(v), true
	case float64:
		return v, true
	}

	return 0, false
}