feat(vm): add stack-based virtual machine

2026-08-25 12:25:00 +02:00
1 parent a7239932fb
commit 34ec137a70
@@ -0,0 +1,508 @@
 package lumen.vm
 import lumen.RuntimeError
 import lumen.bytecode.Chunk
 import lumen.bytecode.Opcode
 import lumen.runtime.*
 private class CallFrame(val closure: ClosureValue, var ip: Int, val slotBase: Int)
 class Vm(val out: Appendable = System.out) {
    private val stack = ArrayList<Value>(256)
    private val frames = ArrayList<CallFrame>()
    private val openUpvalues = ArrayList<Upvalue>()
    val globals = HashMap<String, Value>()
    val methods = HashMap<String, Method>()
    init {
        installBuiltins(this)
        installMethods(this)
    }
    fun defineMethod(method: Method) {
        methods[method.name] = method
    }
    fun defineNative(name: String, native: NativeFunctionValue) {
        globals[name] = native
    }
    fun interpret(script: FunctionValue): Value {
        stack.clear()
        frames.clear()
        openUpvalues.clear()
        val closure = ClosureValue(script, emptyArray())
        push(closure)
        frames.add(CallFrame(closure, 0, 0))
        return run(0)
    }
    fun invoke(callable: Value, args: List<Value>): Value {
        when (callable) {
            is NativeFunctionValue -> {
                checkArity(callable, args.size)
                return callable.call(args)
            }
            is ClosureValue -> {
                if (callable.function.arity != args.size) {
                    throw RuntimeError(
                        "function '${callable.function.name}' expects ${callable.function.arity} arguments but got ${args.size}",
                        0
                    )
                }
                val floor = frames.size
                push(callable)
                args.forEach { push(it) }
                frames.add(CallFrame(callable, 0, stack.size - args.size - 1))
                run(floor)
                return pop()
            }
            else -> throw RuntimeError("value of type ${typeName(callable)} is not callable", 0)
        }
    }
    private fun run(exitFrameFloor: Int): Value {
        while (true) {
            val frame = frames[frames.size - 1]
            val chunk = frame.closure.function.chunk
            when (Opcode.from(readByte(frame, chunk))) {
                Opcode.Constant -> push(chunk.constants[readByte(frame, chunk)])
                Opcode.Nil -> push(NilValue)
                Opcode.True -> push(BoolValue(true))
                Opcode.False -> push(BoolValue(false))
                Opcode.Pop -> pop()
                Opcode.Add -> binaryAdd(frame, chunk)
                Opcode.Sub -> arithmetic(frame, chunk, Arith.Sub)
                Opcode.Mul -> arithmetic(frame, chunk, Arith.Mul)
                Opcode.Div -> arithmetic(frame, chunk, Arith.Div)
                Opcode.Mod -> arithmetic(frame, chunk, Arith.Mod)
                Opcode.Negate -> negate(frame, chunk)
                Opcode.Equal -> {
                    val b = pop()
                    val a = pop()
                    push(BoolValue(valuesEqual(a, b)))
                }
                Opcode.NotEqual -> {
                    val b = pop()
                    val a = pop()
                    push(BoolValue(!valuesEqual(a, b)))
                }
                Opcode.Less -> compare(frame, chunk, Compare.Less)
                Opcode.LessEqual -> compare(frame, chunk, Compare.LessEqual)
                Opcode.Greater -> compare(frame, chunk, Compare.Greater)
                Opcode.GreaterEqual -> compare(frame, chunk, Compare.GreaterEqual)
                Opcode.Not -> push(BoolValue(!isTruthy(pop())))
                Opcode.GetLocal -> {
                    val slot = readByte(frame, chunk)
                    push(stack[frame.slotBase + slot])
                }
                Opcode.SetLocal -> {
                    val slot = readByte(frame, chunk)
                    stack[frame.slotBase + slot] = peek(0)
                }
                Opcode.GetGlobal -> {
                    val name = constantName(chunk, readByte(frame, chunk))
                    val value = globals[name] ?: throw RuntimeError("undefined variable '$name'", lineOf(frame, chunk), columnOf(frame, chunk))
                    push(value)
                }
                Opcode.SetGlobal -> {
                    val name = constantName(chunk, readByte(frame, chunk))
                    if (!globals.containsKey(name)) {
                        throw RuntimeError("undefined variable '$name'", lineOf(frame, chunk), columnOf(frame, chunk))
                    }
                    globals[name] = peek(0)
                }
                Opcode.DefineGlobal -> {
                    val name = constantName(chunk, readByte(frame, chunk))
                    globals[name] = pop()
                }
                Opcode.GetUpvalue -> {
                    val index = readByte(frame, chunk)
                    push(readUpvalue(frame.closure.upvalues[index]))
                }
                Opcode.SetUpvalue -> {
                    val index = readByte(frame, chunk)
                    writeUpvalue(frame.closure.upvalues[index], peek(0))
                }
                Opcode.Jump -> {
                    val offset = readByte(frame, chunk)
                    frame.ip += offset
                }
                Opcode.JumpIfFalse -> {
                    val offset = readByte(frame, chunk)
                    if (!isTruthy(peek(0))) frame.ip += offset
                }
                Opcode.Loop -> {
                    val offset = readByte(frame, chunk)
                    frame.ip -= offset
                }
                Opcode.Call -> {
                    val argCount = readByte(frame, chunk)
                    callValue(peek(argCount), argCount, frame, chunk)
                }
                Opcode.Invoke -> invoke(frame, chunk)
                Opcode.Closure -> makeClosure(frame, chunk)
                Opcode.CloseUpvalue -> {
                    closeUpvalues(stack.size - 1)
                    pop()
                }
                Opcode.Return -> {
                    val result = pop()
                    closeUpvalues(frame.slotBase)
                    frames.removeAt(frames.size - 1)
                    truncate(frame.slotBase)
                    push(result)
                    if (frames.size == exitFrameFloor) return result
                }
                Opcode.BuildList -> buildList(frame, chunk)
                Opcode.BuildMap -> buildMap(frame, chunk)
                Opcode.IndexGet -> indexGet(frame, chunk)
                Opcode.IndexSet -> indexSet(frame, chunk)
                Opcode.GetIter -> push(IteratorValue(makeIterator(pop(), frame, chunk)))
                Opcode.ForIter -> {
                    val iterSlot = readByte(frame, chunk)
                    val offset = readByte(frame, chunk)
                    val iterator = stack[frame.slotBase + iterSlot] as IteratorValue
                    if (iterator.iterator.hasNext()) push(iterator.iterator.next())
                    else frame.ip += offset
                }
            }
        }
    }
    private fun callValue(callee: Value, argCount: Int, frame: CallFrame, chunk: Chunk) {
        when (callee) {
            is ClosureValue -> {
                if (callee.function.arity != argCount) {
                    throw RuntimeError(
                        "function '${callee.function.name}' expects ${callee.function.arity} arguments but got $argCount",
                        lineOf(frame, chunk),
                        columnOf(frame, chunk)
                    )
                }
                frames.add(CallFrame(callee, 0, stack.size - argCount - 1))
            }
            is NativeFunctionValue -> {
                val args = ArrayList<Value>(argCount)
                for (i in 0 until argCount) args.add(stack[stack.size - argCount + i])
                if (!callee.arity.contains(argCount)) {
                    throw RuntimeError(arityMessage(callee, argCount), lineOf(frame, chunk), columnOf(frame, chunk))
                }
                truncate(stack.size - argCount - 1)
                val produced = try {
                    callee.call(args)
                } catch (error: RuntimeError) {
                    if (error.line == 0) {
                        throw RuntimeError(error.rawMessage, lineOf(frame, chunk), columnOf(frame, chunk))
                    }
                    throw error
                }
                push(produced)
            }
            else -> throw RuntimeError("value of type ${typeName(callee)} is not callable", lineOf(frame, chunk), columnOf(frame, chunk))
        }
    }
    private fun invoke(frame: CallFrame, chunk: Chunk) {
        val name = constantName(chunk, readByte(frame, chunk))
        val argCount = readByte(frame, chunk)
        val receiver = peek(argCount)
        val method = methods[name]
            ?: throw RuntimeError("unknown method '$name' on value of type ${typeName(receiver)}", lineOf(frame, chunk), columnOf(frame, chunk))
        if (!method.arity.contains(argCount)) {
            throw RuntimeError(
                "method '$name' expects ${arityText(method.arity)} arguments but got $argCount",
                lineOf(frame, chunk),
                columnOf(frame, chunk)
            )
        }
        val args = ArrayList<Value>(argCount)
        for (i in 0 until argCount) args.add(stack[stack.size - argCount + i])
        val result = try {
            method.call(this, receiver, args)
        } catch (error: RuntimeError) {
            if (error.line == 0) {
                throw RuntimeError(error.rawMessage, lineOf(frame, chunk), columnOf(frame, chunk))
            }
            throw error
        }
        truncate(stack.size - argCount - 1)
        push(result)
    }
    private fun makeClosure(frame: CallFrame, chunk: Chunk) {
        val function = chunk.constants[readByte(frame, chunk)] as FunctionValue
        val upvalues = Array(function.upvalueCount) {
            val isLocal = readByte(frame, chunk) == 1
            val index = readByte(frame, chunk)
            if (isLocal) captureUpvalue(frame.slotBase + index) else frame.closure.upvalues[index]
        }
        push(ClosureValue(function, upvalues))
    }
    private fun buildList(frame: CallFrame, chunk: Chunk) {
        val count = readByte(frame, chunk)
        val items = ArrayList<Value>(count)
        for (i in 0 until count) items.add(NilValue)
        for (i in count - 1 downTo 0) items[i] = pop()
        push(ListValue(items))
    }
    private fun buildMap(frame: CallFrame, chunk: Chunk) {
        val count = readByte(frame, chunk)
        val pairs = ArrayList<Pair<Value, Value>>(count)
        for (i in 0 until count) {
            val value = pop()
            val key = pop()
            pairs.add(key to value)
        }
        pairs.reverse()
        val entries = LinkedHashMap<Value, Value>()
        for ((key, value) in pairs) entries[key] = value
        push(MapValue(entries))
    }
    private fun indexGet(frame: CallFrame, chunk: Chunk) {
        val index = pop()
        val target = pop()
        push(readIndex(target, index, frame, chunk))
    }
    private fun indexSet(frame: CallFrame, chunk: Chunk) {
        val value = pop()
        val index = pop()
        val target = pop()
        writeIndex(target, index, value, frame, chunk)
        push(value)
    }
    private fun readIndex(target: Value, index: Value, frame: CallFrame, chunk: Chunk): Value = when (target) {
        is ListValue -> {
            val i = intIndex(index, frame, chunk)
            if (i < 0 || i >= target.items.size) {
                throw RuntimeError("list index $i out of range 0..${target.items.size - 1}", lineOf(frame, chunk), columnOf(frame, chunk))
            }
            target.items[i]
        }
        is MapValue -> target.entries[index] ?: NilValue
        is StringValue -> {
            val i = intIndex(index, frame, chunk)
            if (i < 0 || i >= target.value.length) {
                throw RuntimeError("string index $i out of range", lineOf(frame, chunk), columnOf(frame, chunk))
            }
            StringValue(target.value[i].toString())
        }
        is RangeValue -> {
            val i = intIndex(index, frame, chunk).toLong()
            if (i < 0 || i >= target.length()) {
                throw RuntimeError("range index $i out of range", lineOf(frame, chunk), columnOf(frame, chunk))
            }
            IntValue(target.elementAt(i))
        }
        else -> throw RuntimeError("value of type ${typeName(target)} is not indexable", lineOf(frame, chunk), columnOf(frame, chunk))
    }
    private fun writeIndex(target: Value, index: Value, value: Value, frame: CallFrame, chunk: Chunk) {
        when (target) {
            is ListValue -> {
                val i = intIndex(index, frame, chunk)
                if (i < 0 || i >= target.items.size) {
                    throw RuntimeError("list index $i out of range 0..${target.items.size - 1}", lineOf(frame, chunk), columnOf(frame, chunk))
                }
                target.items[i] = value
            }
            is MapValue -> target.entries[index] = value
            else -> throw RuntimeError("value of type ${typeName(target)} does not support index assignment", lineOf(frame, chunk), columnOf(frame, chunk))
        }
    }
    private fun intIndex(index: Value, frame: CallFrame, chunk: Chunk): Int {
        if (index !is IntValue) {
            throw RuntimeError("index must be an int, got ${typeName(index)}", lineOf(frame, chunk), columnOf(frame, chunk))
        }
        return index.value.toInt()
    }
    private fun makeIterator(iterable: Value, frame: CallFrame, chunk: Chunk): Iterator<Value> = when (iterable) {
        is ListValue -> ArrayList(iterable.items).iterator()
        is MapValue -> ArrayList(iterable.entries.keys).iterator()
        is StringValue -> iterable.value.map { StringValue(it.toString()) as Value }.iterator()
        is RangeValue -> rangeIterator(iterable)
        else -> throw RuntimeError("value of type ${typeName(iterable)} is not iterable", lineOf(frame, chunk), columnOf(frame, chunk))
    }
    private fun rangeIterator(range: RangeValue): Iterator<Value> = iterator {
        var value = range.start
        if (range.step > 0) {
            while (value < range.end) {
                yield(IntValue(value))
                value += range.step
            }
        } else {
            while (value > range.end) {
                yield(IntValue(value))
                value += range.step
            }
        }
    }
    private enum class Arith { Sub, Mul, Div, Mod }
    private enum class Compare { Less, LessEqual, Greater, GreaterEqual }
    private fun binaryAdd(frame: CallFrame, chunk: Chunk) {
        val b = pop()
        val a = pop()
        val result = when {
            a is IntValue && b is IntValue -> IntValue(a.value + b.value)
            a is StringValue && b is StringValue -> StringValue(a.value + b.value)
            isNumber(a) && isNumber(b) -> DoubleValue(asDouble(a) + asDouble(b))
            else -> throw RuntimeError("cannot add ${typeName(a)} and ${typeName(b)}", lineOf(frame, chunk), columnOf(frame, chunk))
        }
        push(result)
    }
    private fun arithmetic(frame: CallFrame, chunk: Chunk, op: Arith) {
        val b = pop()
        val a = pop()
        if (a is IntValue && b is IntValue) {
            val x = a.value
            val y = b.value
            val result = when (op) {
                Arith.Sub -> x - y
                Arith.Mul -> x * y
                Arith.Div -> {
                    if (y == 0L) throw RuntimeError("division by zero", lineOf(frame, chunk), columnOf(frame, chunk))
                    x / y
                }
                Arith.Mod -> {
                    if (y == 0L) throw RuntimeError("modulo by zero", lineOf(frame, chunk), columnOf(frame, chunk))
                    x % y
                }
            }
            push(IntValue(result))
            return
        }
        if (isNumber(a) && isNumber(b)) {
            val x = asDouble(a)
            val y = asDouble(b)
            val result = when (op) {
                Arith.Sub -> x - y
                Arith.Mul -> x * y
                Arith.Div -> x / y
                Arith.Mod -> x % y
            }
            push(DoubleValue(result))
            return
        }
        throw RuntimeError("cannot apply arithmetic to ${typeName(a)} and ${typeName(b)}", lineOf(frame, chunk), columnOf(frame, chunk))
    }
    private fun negate(frame: CallFrame, chunk: Chunk) {
        when (val operand = pop()) {
            is IntValue -> push(IntValue(-operand.value))
            is DoubleValue -> push(DoubleValue(-operand.value))
            else -> throw RuntimeError("cannot negate ${typeName(operand)}", lineOf(frame, chunk), columnOf(frame, chunk))
        }
    }
    private fun compare(frame: CallFrame, chunk: Chunk, op: Compare) {
        val b = pop()
        val a = pop()
        val ordering = when {
            isNumber(a) && isNumber(b) -> asDouble(a).compareTo(asDouble(b))
            a is StringValue && b is StringValue -> a.value.compareTo(b.value)
            else -> throw RuntimeError("cannot compare ${typeName(a)} and ${typeName(b)}", lineOf(frame, chunk), columnOf(frame, chunk))
        }
        val result = when (op) {
            Compare.Less -> ordering < 0
            Compare.LessEqual -> ordering <= 0
            Compare.Greater -> ordering > 0
            Compare.GreaterEqual -> ordering >= 0
        }
        push(BoolValue(result))
    }
    private fun captureUpvalue(location: Int): Upvalue {
        for (existing in openUpvalues) {
            if (existing.location == location) return existing
        }
        val created = Upvalue(location)
        openUpvalues.add(created)
        return created
    }
    private fun closeUpvalues(fromLocation: Int) {
        val iterator = openUpvalues.iterator()
        while (iterator.hasNext()) {
            val upvalue = iterator.next()
            if (upvalue.location >= fromLocation) {
                upvalue.closed = stack[upvalue.location]
                upvalue.location = -1
                iterator.remove()
            }
        }
    }
    private fun readUpvalue(upvalue: Upvalue): Value =
        if (upvalue.isClosed) upvalue.closed else stack[upvalue.location]
    private fun writeUpvalue(upvalue: Upvalue, value: Value) {
        if (upvalue.isClosed) upvalue.closed = value else stack[upvalue.location] = value
    }
    private fun checkArity(native: NativeFunctionValue, argCount: Int) {
        if (!native.arity.contains(argCount)) {
            throw RuntimeError(arityMessage(native, argCount), 0)
        }
    }
    private fun arityMessage(native: NativeFunctionValue, argCount: Int): String {
        val expected = if (native.arity.first == native.arity.last) "${native.arity.first}"
        else "${native.arity.first}..${native.arity.last}"
        return "builtin '${native.name}' expects $expected arguments but got $argCount"
    }
    private fun constantName(chunk: Chunk, index: Int): String = (chunk.constants[index] as StringValue).value
    private fun readByte(frame: CallFrame, chunk: Chunk): Int = chunk.code[frame.ip++]
    private fun lineOf(frame: CallFrame, chunk: Chunk): Int {
        val index = (frame.ip - 1).coerceIn(0, chunk.lines.size - 1)
        return if (chunk.lines.isEmpty()) 0 else chunk.lines[index]
    }
    private fun columnOf(frame: CallFrame, chunk: Chunk): Int {
        val index = (frame.ip - 1).coerceIn(0, chunk.columns.size - 1)
        return if (chunk.columns.isEmpty()) 0 else chunk.columns[index]
    }
    private fun arityText(arity: IntRange): String =
        if (arity.first == arity.last) "${arity.first}" else "${arity.first}..${arity.last}"
    private fun push(value: Value) {
        stack.add(value)
    }
    private fun pop(): Value = stack.removeAt(stack.size - 1)
    private fun peek(distance: Int): Value = stack[stack.size - 1 - distance]
    private fun truncate(size: Int) {
        while (stack.size > size) stack.removeAt(stack.size - 1)
    }
    private fun isNumber(value: Value): Boolean = value is IntValue || value is DoubleValue
    private fun asDouble(value: Value): Double = when (value) {
        is IntValue -> value.value.toDouble()
        is DoubleValue -> value.value
        else -> 0.0
    }
 }