ft: impl ret

src/interpreter/computer.rs

@@ -1,6 +1,6 @@
 use core::fmt;
 
-use crate::operands::{ImmediateOperand, MemoryIndex, ModRmTarget};
+use crate::operands::{ImmediateOperand, ModRmTarget, Word};
 
 use super::{flags::Flags, interpreter::InterpreterError, memory::Memory, register::Register};
 
@@ -11,13 +11,6 @@ pub enum ArithmeticOperand {
     ModRmTarget(ModRmTarget),
 }
 
-/// Wrapper for easier argument passing of polymorph pop operations.
-#[derive(Debug, Clone)]
-pub enum PopTarget {
-    Register(crate::register::Register),
-    MemoryIndex(MemoryIndex),
-}
-
 type ArithmeticResult = ImmediateOperand;
 type Lhs = ImmediateOperand;
 type Rhs = ImmediateOperand;
@@ -45,19 +38,10 @@ impl Computer {
     }
 
     /// Retrieve value from stack and increment stack pointer.
-    pub fn pop_stack(&mut self, target: PopTarget) -> Result<(), InterpreterError> {
+    pub fn pop_stack(&mut self) -> Result<Word, InterpreterError> {
         let word = self.memory.read_raw(self.regs.sp)?;
-
-        match target {
-            PopTarget::Register(reg) => self.regs.write(reg, word.into()),
-            PopTarget::MemoryIndex(mem_idx) => self
-                .memory
-                .write_raw(Memory::calc_memidx(&self.regs, mem_idx).into(), word.into())?,
-        }
-
         self.regs.pop()?;
-
-        Ok(())
+        Ok(word)
     }
 
     /// Perform binary `dest` = `dest` + `src`. Sets flags.
@@ -163,7 +147,9 @@ impl Computer {
             }
             ArithmeticOperand::ModRmTarget(mod_rm_target) => {
                 ArithmeticOperand::Immediate(match mod_rm_target {
-                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
+                    ModRmTarget::Memory(idx) => {
+                        (self.memory.read(&self.regs, idx) + cf as u16).into()
+                    }
                     ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
                 })
             }
@@ -189,7 +175,9 @@ impl Computer {
             }
             ArithmeticOperand::ModRmTarget(mod_rm_target) => {
                 ArithmeticOperand::Immediate(match mod_rm_target {
-                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
+                    ModRmTarget::Memory(idx) => {
+                        (self.memory.read(&self.regs, idx) + cf as u16).into()
+                    }
                     ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
                 })
             }
@@ -243,7 +231,7 @@ impl Computer {
     /// Read an [`ImmediateOperand`] from [`Self::memory`] or [`Self::regs`].
     pub fn read_modrm(&self, target: ModRmTarget) -> ImmediateOperand {
         match target {
-            ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx),
+            ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx).into(),
             ModRmTarget::Register(reg) => self.regs.read(reg),
         }
     }
@@ -265,10 +253,6 @@ mod tests {
         let mut c = Computer::new();
         let val = ImmediateOperand::Word(0x1234);
         c.push_stack(val).unwrap();
-
-        let target = PopTarget::Register(crate::register::Register::AX);
-        c.pop_stack(target).unwrap();
-
-        assert_eq!(val, c.regs.read(crate::register::Register::AX))
+        assert_eq!(val, c.pop_stack().unwrap().into())
     }
 }