ft(interpreter): impl low hanging fruits

src/interpreter/interpreter.rs

@@ -130,7 +130,9 @@ impl Interpreter {
                 Mnemonic::PUSH_Mod(target) => self
                     .computer
                     .push_stack(self.computer.read_modrm(target)?)?,
-                Mnemonic::PUSH_S(_) => todo!(),
+                Mnemonic::PUSH_S(sreg) => self
+                    .computer
+                    .push_stack(self.computer.sregs.read(sreg).into())?,
 
                 /*
                  * POP
@@ -550,15 +552,21 @@ impl Interpreter {
                     .computer
                     .regs
                     .write(reg, self.computer.read_modrm(target)?),
-                Mnemonic::MOV_FromSReg(_, _) => todo!(),
+                Mnemonic::MOV_FromSReg(target, sreg) => self
+                    .computer
+                    .write_modrm(target, self.computer.sregs.read(sreg).into())?,
                 Mnemonic::MOV_ToSReg(_, _) => todo!(),
                 Mnemonic::MOV_Ib(target, val) => self.computer.write_modrm(target, val.into())?,
                 Mnemonic::MOV_Iv(target, val) => self.computer.write_modrm(target, val.into())?,
 
                 Mnemonic::MOV_AL0b(val) => self.computer.regs.ax.lower = val,
                 Mnemonic::MOV_AX0v(val) => self.computer.regs.ax.write(val),
-                Mnemonic::MOV_0bAL(_) => todo!(),
+                Mnemonic::MOV_0bAL(b) => self
-                Mnemonic::MOV_0vAX(_) => todo!(),
+                    .computer
+                    .write(self.computer.regs.ax.lower.into(), b.into())?,
+                Mnemonic::MOV_0vAX(w) => self
+                    .computer
+                    .write(self.computer.regs.ax.read().into(), w.into())?,
 
                 Mnemonic::MOV_ALIb(val) => self.computer.regs.ax.lower = val,
                 Mnemonic::MOV_CLIb(val) => self.computer.regs.cx.lower = val,

src/interpreter/register.rs

@@ -161,6 +161,32 @@ impl SegmentRegister {
             cs: 0,
         }
     }
+
+    pub fn read(&self, sreg: crate::register::SegmentRegister) -> Word {
+        match sreg {
+            crate::register::SegmentRegister::DS => self.ds,
+            crate::register::SegmentRegister::ES => self.es,
+            crate::register::SegmentRegister::SS => self.ss,
+            crate::register::SegmentRegister::CS => self.cs,
+        }
+    }
+
+    pub fn write(&mut self, sreg: crate::register::SegmentRegister, val: ImmediateOperand) {
+        match val {
+            ImmediateOperand::Byte(b) => match sreg {
+                crate::register::SegmentRegister::DS => self.ds = Word::from_le_bytes([b, 0x0]),
+                crate::register::SegmentRegister::ES => self.es = Word::from_le_bytes([b, 0x0]),
+                crate::register::SegmentRegister::SS => self.ss = Word::from_le_bytes([b, 0x0]),
+                crate::register::SegmentRegister::CS => self.cs = Word::from_le_bytes([b, 0x0]),
+            },
+            ImmediateOperand::Word(w) => match sreg {
+                crate::register::SegmentRegister::DS => self.ds = w,
+                crate::register::SegmentRegister::ES => self.es = w,
+                crate::register::SegmentRegister::SS => self.ss = w,
+                crate::register::SegmentRegister::CS => self.cs = w,
+            },
+        }
+    }
 }
 
 impl fmt::Display for SegmentRegister {

src/operands.rs

@@ -576,7 +576,17 @@ pub struct MemoryIndex {
     pub displacement: Option<ImmediateOperand>,
 }
 
-impl Into<MemoryIndex> for u16 {
+impl Into<MemoryIndex> for Word {
+    fn into(self) -> MemoryIndex {
+        MemoryIndex {
+            base: None,
+            index: None,
+            displacement: Some(self.into()),
+        }
+    }
+}
+
+impl Into<MemoryIndex> for Byte {
     fn into(self) -> MemoryIndex {
         MemoryIndex {
             base: None,