ft: introduce modrm macro for leaner matching

All instructions which use a modrm instruction
for memory reads from or into a register can
make use of this macro

src/instructions.rs

@@ -43,10 +43,22 @@ pub enum Opcode {
     NOP(),
     // ADD
     ADD_EbGb(MemoryIndex, Register),
-    // MOV
-    MOV_BXIv(Register, ImmediateWord),
+    ADD_EvGv(MemoryIndex, Register),
+    ADD_GbEb(MemoryIndex, Register),
+    ADD_GvEv(MemoryIndex, Register),
+    ADD_ALIb(ImmediateByte),
+    ADD_AXIv(ImmediateWord),
+    // PUSH
+    PUSH(SegmentRegister),
+    // POP
+    POP(SegmentRegister),
+    // OR
+    OR_EbGb(MemoryIndex, Register),
+    OR_GbEb(MemoryIndex, Register),
     // INT
     INT(ImmediateByte),
+    // MOV
+    MOV_BXIv(ImmediateWord),
 }
 
 impl fmt::Display for Opcode {
@@ -54,7 +66,8 @@ impl fmt::Display for Opcode {
         match self {
             Self::INT(byte) => write!(f, "INT, {:x}", byte),
             Self::ADD_EbGb(mem, reg) => write!(f, "ADD {}, {}", mem, reg),
-            Self::MOV_BXIv(reg, word) => write!(f, "MOV {}, {:04x}", reg, word),
+            Self::ADD_GbEb(mem, reg) => write!(f, "ADD {}, {}", reg, mem),
+            Self::MOV_BXIv(word) => write!(f, "MOV BX, {:04x}", word),
             _ => write!(f, "display not yet implemented"),
         }
     }
@@ -83,10 +96,13 @@ pub enum Register {
     SP,
 }
 
+/// Selector for Register or Segment Register
+pub type RegisterId = u8;
+
 #[allow(dead_code)]
 impl Register {
     /// Find the register corresponding to the 8086 bytecode ID
-    pub fn by_id(id: u8) -> Self {
+    pub fn by_id(id: RegisterId) -> Self {
         match id {
             0x00 => Self::AL,
             0x01 => Self::CL,
@@ -133,7 +149,7 @@ impl fmt::Display for Register {
 }
 
 /// Segment Registers of a 8086 processor
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub enum SegmentRegister {
     DS,
@@ -213,13 +229,13 @@ impl fmt::Display for MemoryIndex {
                 },
                 None => match &self.displacement {
                     Some(displacement) => write!(f, "[{}+{}]", base, displacement),
-                    None => write!(f, "[{}]", base),
+                    None => write!(f, "{}", base),
                 },
             },
             None => match &self.index {
                 Some(index) => match &self.displacement {
                     Some(displacement) => write!(f, "{}+{}", index, displacement),
-                    None => write!(f, "[{}]", index),
+                    None => write!(f, "{}", index),
                 },
                 None => panic!("Invalid MemoryIndex encountered"),
             },