From 4ac9de366bd488ddb9d78c71f7281feff2df0fc3 Mon Sep 17 00:00:00 2001 From: Reid 'arrdem' McKenzie Date: Sat, 13 Aug 2022 00:09:55 -0600 Subject: [PATCH] Make the handle_* methods user-visible --- .../shoggoth/src/python/ichor/interpreter.py | 76 +++++++++---------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/projects/shoggoth/src/python/ichor/interpreter.py b/projects/shoggoth/src/python/ichor/interpreter.py index 9289604..2361019 100644 --- a/projects/shoggoth/src/python/ichor/interpreter.py +++ b/projects/shoggoth/src/python/ichor/interpreter.py @@ -181,23 +181,23 @@ class Interpreter(BaseInterpreter): def step(self, state: InterpreterState, opcode: isa.Opcode) -> InterpreterState: """Execute an instruction, producing the next state of the VM.""" - return self._handle_opcode(state, opcode) + return self.handle_opcode(state, opcode) #################################################################################################################### # BEGIN INSTRUCTION IMPLEMENTATIONS AT LENGTH #################################################################################################################### @opcode_dispatch - def _handle_opcode(self, state: InterpreterState, opcode: isa.Opcode) -> InterpreterState: + def handle_opcode(self, state: InterpreterState, opcode: isa.Opcode) -> InterpreterState: """Generic entrypoint. Exists to establish a type signature and provide singledispatch handling.""" return self.handle_unknown(state, opcode) - @_handle_opcode.register(object) - def _handle_unknown(self, state: InterpreterState, opcode: isa.Opcode) -> InterpreterState: + @handle_opcode.register(object) + def handle_unknown(self, state: InterpreterState, opcode: isa.Opcode) -> InterpreterState: return self.handle_unknown(state, opcode) - @_handle_opcode.register(isa.IDENTIFIERC) - def _handle_identifierc(self, state: InterpreterState, opcode: isa.IDENTIFIERC) -> InterpreterState: + @handle_opcode.register(isa.IDENTIFIERC) + def handle_identifierc(self, state: InterpreterState, opcode: isa.IDENTIFIERC) -> InterpreterState: name = opcode.val if not (name in state.module.functions or name in state.module.types @@ -208,8 +208,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.TYPEREF) - def _handle_typeref(self, state, opcode) -> InterpreterState: + @handle_opcode.register(isa.TYPEREF) + def handle_typeref(self, state, opcode) -> InterpreterState: id = state.stackframe.pop() if not isinstance(id, Identifier): return self.handle_fault(state, opcode, "TYPEREF consumes an identifier") @@ -221,8 +221,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.ARMREF) - def _handle_armref(self, state, opcode) -> InterpreterState: + @handle_opcode.register(isa.ARMREF) + def handle_armref(self, state, opcode) -> InterpreterState: id: Identifier = state.stackframe.pop() if not isinstance(id, Identifier): return self.handle_fault(state, opcode, "VARIANTREF consumes an identifier and a typeref") @@ -239,8 +239,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.ARM) - def _handle_arm(self, state: InterpreterState, opcode: isa.ARM) -> InterpreterState: + @handle_opcode.register(isa.ARM) + def handle_arm(self, state: InterpreterState, opcode: isa.ARM) -> InterpreterState: armref: VariantRef = state.stackframe.pop() if not isinstance(armref, VariantRef): return self.handle_fault(state, opcode, "VARIANT must be given a valid constructor reference") @@ -260,8 +260,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.ATEST) - def _handle_atest(self, state: InterpreterState, opcode: isa.ATEST) -> InterpreterState: + @handle_opcode.register(isa.ATEST) + def handle_atest(self, state: InterpreterState, opcode: isa.ATEST) -> InterpreterState: armref: VariantRef = state.stackframe.pop() if not isinstance(armref, VariantRef): return self.handle_fault(state, opcode, "VTEST must be given a variant reference") @@ -277,15 +277,15 @@ class Interpreter(BaseInterpreter): return state - @_handle_opcode.register(isa.GOTO) - def _handle_goto(self, state, opcode: isa.GOTO) -> InterpreterState: + @handle_opcode.register(isa.GOTO) + def handle_goto(self, state, opcode: isa.GOTO) -> InterpreterState: if (opcode.target < 0): return self.handle_fault(state, opcode, "Illegal branch target") state.stackframe.goto(opcode.target) return state - @_handle_opcode.register(isa.DUP) - def _handle_dupe(self, state, opcode: isa.DUP) -> InterpreterState: + @handle_opcode.register(isa.DUP) + def handle_dupe(self, state, opcode: isa.DUP) -> InterpreterState: if (opcode.nargs > len(state.stackframe)): return self.handle_fault(state, opcode, "Stack size violation") @@ -293,8 +293,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.ROT) - def _handle_rot(self, state, opcode: isa.DUP) -> InterpreterState: + @handle_opcode.register(isa.ROT) + def handle_rot(self, state, opcode: isa.DUP) -> InterpreterState: if (opcode.nargs > len(state.stackframe)): return self.handle_fault(state, opcode, "Stack size violation") @@ -302,8 +302,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.DROP) - def _handle_drop(self, state, opcode: isa.DROP) -> InterpreterState: + @handle_opcode.register(isa.DROP) + def handle_drop(self, state, opcode: isa.DROP) -> InterpreterState: if (opcode.nargs > len(state.stackframe)): return self.handle_fault(state, opcode, "Stack size violation") @@ -311,8 +311,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.SLOT) - def _handle_slot(self, state, opcode: isa.SLOT) -> InterpreterState: + @handle_opcode.register(isa.SLOT) + def handle_slot(self, state, opcode: isa.SLOT) -> InterpreterState: if (opcode.target < 0): return self.handle_fault(state, opcode, "SLOT must have a positive reference") @@ -323,8 +323,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.FUNREF) - def _handle_funref(self, state, opcode) -> InterpreterState: + @handle_opcode.register(isa.FUNREF) + def handle_funref(self, state, opcode) -> InterpreterState: id = state.stackframe.pop() if not isinstance(id, Identifier): return self.handle_fault(state, opcode, "FUNREF consumes an IDENTIFIER") @@ -337,8 +337,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.CALLF) - def _handle_callf(self, state, opcode: isa.CALLF) -> InterpreterState: + @handle_opcode.register(isa.CALLF) + def handle_callf(self, state, opcode: isa.CALLF) -> InterpreterState: sig = state.stackframe.pop() if not isinstance(sig, FunctionRef): return self.handle_fault(state, opcode, "CALLF requires a funref at top of stack") @@ -358,8 +358,8 @@ class Interpreter(BaseInterpreter): return state - @_handle_opcode.register(isa.RETURN) - def _handle_return(self, state, opcode: isa.RETURN) -> InterpreterState: + @handle_opcode.register(isa.RETURN) + def handle_return(self, state, opcode: isa.RETURN) -> InterpreterState: n = 1 # FIXME: clean this up if (n > len(state.stackframe)): return self.handle_fault(state, opcode, "Stack size violation") @@ -373,8 +373,8 @@ class Interpreter(BaseInterpreter): state.stackframe = state.stackframe.ret(n) return state - @_handle_opcode.register(isa.CLOSUREF) - def _handle_closuref(self, state: InterpreterState, opcode: isa.CLOSUREF) -> InterpreterState: + @handle_opcode.register(isa.CLOSUREF) + def handle_closuref(self, state: InterpreterState, opcode: isa.CLOSUREF) -> InterpreterState: n = opcode.nargs sig = state.stackframe.pop() @@ -397,8 +397,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.CLOSUREC) - def _handle_closurec(self, state, opcode: isa.CLOSUREC) -> InterpreterState: + @handle_opcode.register(isa.CLOSUREC) + def handle_closurec(self, state, opcode: isa.CLOSUREC) -> InterpreterState: n = opcode.nargs c = state.stackframe.pop() @@ -421,8 +421,8 @@ class Interpreter(BaseInterpreter): state.stackframe._ip += 1 return state - @_handle_opcode.register(isa.CALLC) - def _handle_callc(self, state, opcode: isa.CALLC) -> InterpreterState: + @handle_opcode.register(isa.CALLC) + def handle_callc(self, state, opcode: isa.CALLC) -> InterpreterState: n = opcode.nargs c = state.stackframe.pop() if not isinstance(c, Closure): @@ -445,6 +445,6 @@ class Interpreter(BaseInterpreter): state.stackframe = state.stackframe.call(fun, ip) return state - @_handle_opcode.register(isa.BREAK) - def _handle_break(self, state, _) -> InterpreterState: + @handle_opcode.register(isa.BREAK) + def handle_break(self, state, _) -> InterpreterState: raise InterpreterReturn(state.stackframe._stack)