Swap out execution status for instructions returning an InstructionResult

src/core.rs

@@ -3,18 +3,19 @@ use crate::{
     mem::MemConfig,
 };
 
-#[derive(PartialEq, Debug, Clone, Copy)]
+// placeholder - change when exception system is in place
-pub enum ExecutionStatus {
+pub(crate) type Exception = ();
-    Running,
+
-    Paused,
+pub(crate) enum InstructionResult {
-    Halted,
+    Normal,
+    Exception(Exception),
+    Pause,
 }
 
 pub struct Core {
     x_regs: [RegValue; 32],
     pc: Addr,
     mem: MemConfig,
-    exec_status: ExecutionStatus,
 }
 
 impl Core {
@@ -23,26 +24,11 @@ impl Core {
             x_regs: [0; 32],
             pc: 0,
             mem,
-            exec_status: ExecutionStatus::Halted,
         }
     }
 
     pub fn reset(&mut self, pc: Addr) {
         self.pc = pc;
-        self.exec_status = ExecutionStatus::Running;
-    }
-
-    pub fn resume(&mut self) -> ExecutionStatus {
-        if self.exec_status == ExecutionStatus::Halted {
-            ExecutionStatus::Halted
-        } else {
-            self.exec_status = ExecutionStatus::Running;
-            ExecutionStatus::Running
-        }
-    }
-
-    pub fn exec_status(&self) -> ExecutionStatus {
-        self.exec_status
     }
 
     fn reg_read(&self, id: RegId) -> RegValue {

src/instructions.rs

@@ -6,9 +6,13 @@ static INSTRUCTIONS: Lazy<[Option<OpcodeHandler>; 32]> = Lazy::new(|| {
     instructions
 });
 
-use crate::{consts::Word, core::Core, decode::Instruction};
+use crate::{
+    consts::Word,
+    core::{Core, InstructionResult},
+    decode::Instruction,
+};
 
-type Runner = fn(&mut Core, Instruction) -> Result<(), ()>;
+type Runner = fn(&mut Core, Instruction) -> Result<(), InstructionResult>;
 
 #[derive(Clone, Copy)]
 struct InstructionHandler {