chore: Rename Operand -> ImmediateOperand

src/interpreter/computer.rs

@@ -1,13 +1,13 @@
 use core::fmt;
 
-use crate::operands::{ModRmTarget, Operand};
+use crate::operands::{ImmediateOperand, ModRmTarget};
 
 use super::{flags::Flags, memory::Memory, register::Register};
 
 /// Wrapper for easier argument passing of arithmetic operations.
 #[derive(Debug, Clone)]
-pub enum Argument {
-    Operand(crate::operands::Operand),
+pub enum Operand {
+    Immediate(crate::operands::ImmediateOperand),
     ModRmTarget(ModRmTarget),
 }
 
@@ -30,10 +30,10 @@ impl Computer {
     /// Adds two [`Argument`]s, saves it to `dest` and sets flags, if necessary.
     /// A value can never be saved to an immediate Operand, so `dest` can only
     /// be a [`ModRmTarget`].
-    pub fn add(&mut self, dest: ModRmTarget, src: Argument) {
+    pub fn add(&mut self, dest: ModRmTarget, src: Operand) {
         match src {
-            Argument::ModRmTarget(src_target) => self.add_modrm(dest, src_target),
-            Argument::Operand(src_operand) => self.add_imm(dest, src_operand),
+            Operand::ModRmTarget(src_target) => self.add_modrm(dest, src_target),
+            Operand::Immediate(src_operand) => self.add_imm(dest, src_operand),
         }
     }
 
@@ -45,11 +45,10 @@ impl Computer {
                 ModRmTarget::Memory(_) => panic!("Cannot add Memory to Memory!"),
                 // mem, reg
                 ModRmTarget::Register(src_register) => {
-                    let lhs = self.memory.read_from_memidx(&self.regs, dest_memory_idx);
+                    let lhs = self.memory.read(&self.regs, dest_memory_idx);
                     let rhs = self.regs.read(src_register);
                     let result = lhs + rhs;
-                    self.memory
-                        .write_from_memidx(&self.regs, dest_memory_idx, result);
+                    self.memory.write(&self.regs, dest_memory_idx, result);
                     // unsigned overflow
                     self.flags.of = result < rhs;
                 }
@@ -58,7 +57,7 @@ impl Computer {
                 // reg, mem
                 ModRmTarget::Memory(src_memory_index) => {
                     let lhs = self.regs.read(dest_register);
-                    let rhs = self.memory.read_from_memidx(&self.regs, src_memory_index);
+                    let rhs = self.memory.read(&self.regs, src_memory_index);
                     let result = lhs + rhs;
                     self.regs.write(dest_register, result);
                     // unsigned overflow
@@ -78,16 +77,16 @@ impl Computer {
         }
     }
 
-    /// Adds an immediate [`Operand`] to a location pointed to by a
+    /// Adds an [`ImmediateOperand`] to a location pointed to by a
     /// [`ModRmTarget`], saves it to dest and sets flags, if necessary.
-    fn add_imm(&mut self, dest: ModRmTarget, src: Operand) {
+    fn add_imm(&mut self, dest: ModRmTarget, src: ImmediateOperand) {
         match dest {
             ModRmTarget::Memory(dest_mem) => {
-                let lhs = self.memory.read_from_memidx(&self.regs, dest_mem);
+                let lhs = self.memory.read(&self.regs, dest_mem);
                 let result = lhs + src;
                 // unsigned overflow
                 self.flags.of = result < src;
-                self.memory.write_from_memidx(&self.regs, dest_mem, result);
+                self.memory.write(&self.regs, dest_mem, result);
             }
             ModRmTarget::Register(dest_reg) => {
                 let lhs = self.regs.read(dest_reg);