source/projects/shoggoth/src/python/ichor/impl.py

#!/usr/bin/env python3

"""The Ichor VM implementation.

The whole point of Shoggoth is that program executions are checkpointable and restartable. This requires that rather than
using a traditional recursive interpreter which is difficult to snapshot, interpretation in shoggoth occur within a
context (a virtual machine) which DOES have an easily introspected and serialized representation.

"""


from copy import deepcopy
import typing as t
from textwrap import indent

from ichor.isa import Opcode
from ichor.state import Closure, FunctionRef, Identifier, Module, Function, Type, TypeRef, VariantRef, Variant, Stackframe


class InterpreterError(Exception):
    """An error raised by the interpreter when something goes awry."""

    def __init__(self, module, stack, message=None):
        self.module = module
        self.stack = stack
        super().__init__(message)


class Interpreter(object):
    """A shit simple instruction pointer based interpreter."""
    def __init__(self, bootstrap_module: Module):
        self.bootstrap = bootstrap_module

    def run(self, opcodes, stack=[]):
        """Directly interpret some opcodes in the configured environment."""

        mod = self.bootstrap.copy()
        main = mod.define_function(";<main>;;", opcodes)
        main_fun = mod.functions[main]
        main_ip = mod.labels[main]
        stackframe = Stackframe(main_fun, main_ip, stack)
        clock: int = 0

        print(mod)

        def _error(msg=None):
            # Note this is pretty expensive because we have to snapshot the stack BEFORE we do anything
            # And the stack object isn't immutable or otherwise designed for cheap snapshotting
            raise InterpreterError(mod, deepcopy(stackframe), msg)

        def _debug():
            b = []
            b.append(f"clock {clock}:")
            b.append("  stack:")
            for offset, it in zip(range(len(stackframe), 0, -1), stackframe):
                b.append(f"    {offset: <3} {it}")
            b.append(f"  op: {op}")
            print(indent("\n".join(b), "  " * stackframe.depth))


        while True:
            op = mod.codepage[stackframe._ip]
            _debug()
            clock += 1

            match op:
                case Opcode.IDENTIFIERC(name):
                    if not (name in mod.functions
                            or name in mod.types
                            or any(name in t.constructors for t in mod.types.values())):
                        _error("IDENTIFIERC references unknown entity")

                    stackframe.push(Identifier(name))

                case Opcode.TYPEREF():
                    id = stackframe.pop()
                    if not isinstance(id, Identifier):
                        _error("TYPEREF consumes an identifier")
                    if not id.name in mod.types:
                        _error("TYPEREF must be given a valid type identifier")

                    stackframe.push(TypeRef(id.name))

                case Opcode.VARIANTREF():
                    id: Identifier = stackframe.pop()
                    if not isinstance(id, Identifier):
                        _error("VARIANTREF consumes an identifier and a typeref")

                    t: TypeRef = stackframe.pop()
                    if not isinstance(t, TypeRef):
                        _error("VARIANTREF consumes an identifier and a typeref")

                    type = mod.types[t.name]
                    if id.name not in type.constructors:
                        _error(f"VARIANTREF given {id.name!r} which does not name a constructor within {type!r}")

                    stackframe.push(VariantRef(t, id.name))

                case Opcode.VARIANT(n):
                    armref: VariantRef = stackframe.pop()
                    if not isinstance(armref, VariantRef):
                        _error("VARIANT must be given a valid constructor reference")

                    ctor = mod.types[armref.type.name].constructors[armref.arm]
                    if n != len(ctor):
                        _error("VARIANT given n-args inconsistent with the type constructor")

                    if n > len(stackframe):
                        _error("Stack size violation")

                    # FIXME: Where does type variable to type binding occur?
                    # Certainly needs to be AT LEAST here, where we also need to be doing some typechecking
                    v = Variant(armref.type.name, armref.arm, tuple(stackframe[:n]))
                    stackframe.drop(n)
                    stackframe.push(v)

                case Opcode.VTEST(n):
                    armref: VariantRef = stackframe.pop()
                    if not isinstance(armref, VariantRef):
                        _error("VTEST must be given a variant reference")

                    inst: Variant = stackframe.pop()
                    if not isinstance(inst, Variant):
                        _error("VTEST must be given an instance of a variant")

                    if inst.type == armref.type.name and inst.variant == armref.arm:
                        stackframe.goto(n)
                        continue

                case Opcode.GOTO(n):
                    if (n < 0):
                        _error("Illegal branch target")
                    stackframe.goto(n)
                    continue

                case Opcode.DUP(n):
                    if (n > len(stackframe)):
                        _error("Stack size violation")

                    stackframe.dup(n)

                case Opcode.ROT(n):
                    if (n > len(stackframe)):
                        _error("Stack size violation")

                    stackframe.rot(n)

                case Opcode.DROP(n):
                    if (n > len(stackframe)):
                        _error("Stack size violation")

                    stackframe.drop(n)

                case Opcode.SLOT(n):
                    if (n < 0):
                        _error("SLOT must have a positive reference")
                    if (n > len(stackframe) - 1):
                        _error("SLOT reference out of range")
                    stackframe.slot(n)

                case Opcode.FUNREF():
                    id = stackframe.pop()
                    if not isinstance(id, Identifier):
                        _error("FUNREF consumes an IDENTIFIER")
                    try:
                        # FIXME: Verify this statically
                        stackframe.push(FunctionRef.parse(id.name))
                    except:
                        _error("Invalid function ref")

                case Opcode.CALLF(n):
                    sig = stackframe.pop()
                    if not isinstance(sig, FunctionRef):
                        _error("CALLF requires a funref at top of stack")
                    fun = mod.functions[sig.name]
                    if n != len(fun.arguments):
                        _error("CALLF target violation; argument count missmatch")
                    if n > len(stackframe):
                        _error("Stack size violation")

                    try:
                        ip = mod.labels[fun.signature]
                    except KeyError:
                        _error("Unknown target")

                    stackframe = stackframe.call(fun, ip)
                    continue

                case Opcode.RETURN(n):
                    if (n > len(stackframe)):
                        _error("Stack size violation")

                    if stackframe.depth == 0:
                        return stackframe[:n]

                    if (len(stackframe._fun.returns) != n):
                        _error("Signature violation")

                    stackframe = stackframe.ret(n)
                    continue

                case Opcode.CLOSUREF(n):
                    sig = stackframe.pop()
                    if not isinstance(sig, FunctionRef):
                        _error("CLOSUREF requires a funref at top of stack")
                    fun = mod.functions[sig.name]
                    if not n <= len(fun.arguments):
                        _error("CLOSUREF target violation; too many parameters provided")
                    if n > len(stackframe):
                        _error("Stack size violation")

                    c = Closure(
                        sig,
                        stackframe[:n]
                    )
                    stackframe.drop(n)
                    stackframe.push(c)

                case Opcode.CLOSUREC(n):
                    c = stackframe.pop()
                    if not isinstance(c, Closure):
                        _error("CLOSUREC requires a closure at top of stack")
                    fun = mod.functions[c.funref.name]
                    if n + len(c.frag) > len(fun.arguments):
                        _error("CLOSUREC target violation; too many parameters provided")
                    if n > len(stackframe):
                        _error("Stack size violation")

                    c = Closure(
                        c.funref,
                        stackframe[:n] + c.frag
                    )
                    stackframe.drop(n)
                    stackframe.push(c)

                case Opcode.CALLC(n):
                    c = stackframe.pop()
                    if not isinstance(c, Closure):
                        _error("CALLC requires a closure at top of stack")
                    fun = mod.functions[c.funref.name]
                    if n + len(c.frag) != len(fun.arguments):
                        _error("CALLC target vionation; argument count missmatch")
                    if n > len(stackframe):
                        _error("Stack size violation")

                    # Extract the function signature

                    # Push the closure's stack fragment
                    stackframe._stack = stackframe._stack.extendleft(c.frag)

                    # Perform a "normal" funref call
                    try:
                        ip = mod.labels[fun.signature]
                    except KeyError:
                        _error("Unknown target")

                    stackframe = stackframe.call(fun, ip)
                    continue

                case _:
                    raise Exception(f"Unhandled interpreter state {op}")

            stackframe._ip += 1