feat: neg, better formatting

src/disassembler/instruction/instruction.rs

@@ -50,6 +50,8 @@ pub enum IR {
     Pop { dest: Operand },
     Ret,
     In { dest: Operand, src: Operand },
+    Neg { dest: Operand },
+    Undefined,
 }
 
 impl std::fmt::Display for IR {
@@ -111,6 +113,8 @@ impl std::fmt::Display for IR {
             IR::Pop { dest } => write!(f, "pop {}", dest),
             IR::Ret => write!(f, "ret"),
             IR::In { dest, src } => write!(f, "in {}, {}", dest, src),
+            IR::Neg { dest } => write!(f, "neg {}", dest),
+            IR::Undefined => write!(f, "(undefined)"),
         }
     }
 }

src/disassembler/parser.rs

@@ -291,9 +291,7 @@ pub fn parse_instruction(bytes: &[u8], ip: usize) -> Result<(Instruction, usize)
             let bits = (bytes[1] & 0b00111000) >> 3;
             match bits {
                 // NEG
-                0b011 => {
-                    unimplemented!()
-                }
+                0b011 => Ok((IR::Neg { dest: rm }, bytes_consumed + 1)),
                 // MUL
                 0b100 => {
                     unimplemented!()
@@ -1201,6 +1199,21 @@ mod tests {
         assert_eq!(parse_instruction(&bytes, 0), Ok(expected_result));
     }
 
+    #[test]
+    fn test_parse_instruction_neg() {
+        let bytes = [0xf7, 0xda];
+        let expected_result = (
+            Instruction::new(
+                IR::Neg {
+                    dest: Operand::Register(Register::DX),
+                },
+                bytes.to_vec(),
+            ),
+            bytes.len(),
+        );
+        assert_eq!(parse_instruction(&bytes, 0), Ok(expected_result));
+    }
+
     #[test]
     fn test_parse_instruction_invalid_opcode() {
         // Test parsing an invalid opcode

src/disassembler/program.rs

@@ -1,5 +1,5 @@
 use crate::{
-    disassembler::{error::ParseError, parser, Instruction},
+    disassembler::{error::ParseError, parser, Instruction, IR},
     text_segment::TextSegment,
 };
 
@@ -13,13 +13,22 @@ impl Program {
         Program { instructions }
     }
 
-    pub fn from_text_segment(segment: TextSegment) -> Result<Program, ParseError> {
+    pub fn from_text_segment(segment: TextSegment) -> Program {
         let mut instructions = Vec::new();
         let mut text = segment.text.as_slice();
 
         let mut ip = 0;
         while !text.is_empty() {
-            let (instruction, bytes_consumed) = parser::parse_instruction(text, ip)?;
+            let (instruction, bytes_consumed) = match parser::parse_instruction(text, ip) {
+                Ok((instruction, bytes_consumed)) => (instruction, bytes_consumed),
+                Err(ParseError::UnexpectedEOF) => {
+                    (Instruction::new(IR::Undefined, text.to_vec()), text.len())
+                }
+                Err(err) => {
+                    eprintln!("Error: {}", err);
+                    break;
+                }
+            };
             // DEBUG:
             println!("{:04x}: {}", ip, instruction);
             ip += bytes_consumed;
@@ -28,7 +37,7 @@ impl Program {
             text = &text[bytes_consumed..];
         }
 
-        Ok(Program::new(instructions))
+        Program::new(instructions)
     }
 }
 
@@ -53,7 +62,7 @@ mod tests {
         let text_segment = TextSegment {
             text: vec![0xbb, 0xFF, 0x00],
         };
-        let program = Program::from_text_segment(text_segment).unwrap();
+        let program = Program::from_text_segment(text_segment);
         assert_eq!(program.instructions.len(), 1);
         assert_eq!(
             program.instructions[0],

src/main.rs

@@ -42,10 +42,5 @@ fn main() {
     let program = Program::from_text_segment(text_segment);
 
     // Print program (same output as mmvm -d)
-    match program {
-        Ok(p) => println!("{}", p),
-        Err(e) => {
-            println!("Error parsing program: {}", e);
-        }
-    }
+    print!("{}", program);
 }