ft(interpreter): impl push/pop

src/interpreter/computer.rs

@@ -1,16 +1,23 @@
 use core::fmt;
 
-use crate::operands::{ImmediateOperand, ModRmTarget};
+use crate::operands::{ImmediateOperand, MemoryIndex, ModRmTarget};
 
-use super::{flags::Flags, memory::Memory, register::Register};
+use super::{flags::Flags, interpreter::InterpreterError, memory::Memory, register::Register};
 
-/// Wrapper for easier argument passing of multi-type operations.
+/// Wrapper for easier argument passing of polymorph arithmetic operations.
 #[derive(Debug, Clone)]
 pub enum Operand {
     Immediate(crate::operands::ImmediateOperand),
     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;
@@ -31,6 +38,28 @@ impl Computer {
         }
     }
 
+    /// Decrement stack pointer and write `val` onto the stack.
+    pub fn push_stack(&mut self, val: ImmediateOperand) -> Result<(), InterpreterError> {
+        self.regs.push()?;
+        self.memory.write_raw(self.regs.sp, val.into())
+    }
+
+    /// Retrieve value from stack and increment stack pointer.
+    pub fn pop_stack(&mut self, target: PopTarget) -> Result<(), 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(())
+    }
+
     /// Perform binary `dest` = `dest` + `src`. Sets flags.
     pub fn add(&mut self, dest: ModRmTarget, src: Operand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;