271 lines
10 KiB
Python
271 lines
10 KiB
Python
#!/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
|
|
from textwrap import indent
|
|
|
|
from ichor import isa
|
|
from ichor.state import (
|
|
Closure,
|
|
FunctionRef,
|
|
Identifier,
|
|
Module,
|
|
Stackframe,
|
|
TypeRef,
|
|
Variant,
|
|
VariantRef,
|
|
)
|
|
|
|
|
|
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(0, len(stackframe), 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 isa.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 isa.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 isa.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 isa.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 isa.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 isa.GOTO(n):
|
|
if (n < 0):
|
|
_error("Illegal branch target")
|
|
stackframe.goto(n)
|
|
continue
|
|
|
|
case isa.DUP(n):
|
|
if (n > len(stackframe)):
|
|
_error("Stack size violation")
|
|
|
|
stackframe.dup(n)
|
|
|
|
case isa.ROT(n):
|
|
if (n > len(stackframe)):
|
|
_error("Stack size violation")
|
|
|
|
stackframe.rot(n)
|
|
|
|
case isa.DROP(n):
|
|
if (n > len(stackframe)):
|
|
_error("Stack size violation")
|
|
|
|
stackframe.drop(n)
|
|
|
|
case isa.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 isa.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 isa.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 isa.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 isa.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 isa.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 isa.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 = c.frag + stackframe._stack
|
|
|
|
# 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
|