switch away from macro for nasm tests

src/arch/x86_64/test/nasm.rs

@@ -34,15 +34,16 @@ const WIDTHS: &[Width] = &[Width::B8, Width::B16, Width::B32, Width::B64];
 
 #[test]
 fn mov() {
+    let c = &mut Code::default();
     for &r1 in Reg::IMPORTANT {
         for &r2 in Reg::IMPORTANT {
-            eq!(format!("mov {r1}, {r2}"), mov(r1, r2));
+            eq(c, format!("mov {r1}, {r2}"), |c| c.mov(r1, r2));
         }
     }
 
     for &r1 in Reg::IMPORTANT {
         for &imm in IMMS {
-            eq!(format!("mov {r1}, {imm}"), mov(r1, imm));
+            eq(c, format!("mov {r1}, {imm}"), |c| c.mov(r1, imm));
         }
     }
 
@@ -51,31 +52,27 @@ fn mov() {
             for &imm in IMMS {
                 for &width in WIDTHS {
                     let mem = mem(reg, disp, width);
-                    eq!(format!("mov {mem}, {imm}"), mov(mem, imm));
+                    eq(c, format!("mov {mem}, {imm}"), |c| c.mov(mem, imm));
                 }
             }
         }
     }
 }
 
-fn u_to_i(u: u64) -> i64 {
-    match u {
-        0..0x100 => u as i8 as i64,
-        0x100..0x10000 => u as i16 as i64,
-        0x10000..0x100000000 => u as i32 as i64,
-        0x100000000.. => u as i64,
-    }
-}
-
-macro_rules! eq {
-    ($asm:expr, $instr:ident $args:tt $(,)?) => {
-        let asm = $asm;
-        let expected = nasm(asm.as_ref());
-        let mut code = Code::default();
-        let res = code.$instr $args;
+fn eq(
+    code: &mut Code,
+    asm: impl AsRef<str>,
+    instr: impl FnOnce(&mut Code) -> Result<(), CompilerMsg>,
+) {
+    let asm = asm.as_ref();
+    let expected = nasm(asm);
+    let res = instr(code);
     match (expected, res) {
         (Ok(expected), Err(e)) => {
-                panic!("{asm}: failed to compile: {}\nexpected: {expected:x?}", e.msg);
+            panic!(
+                "{asm}: failed to compile: {}\nexpected: {expected:x?}",
+                e.msg
+            );
         }
         (Err(e), Ok(_)) => {
             let res = &code.bytes[..];
@@ -89,9 +86,8 @@ macro_rules! eq {
             }
         }
     }
-    };
+    code.bytes.clear();
 }
-use eq;
 
 fn nasm(input: &str) -> Result<Vec<u8>, String> {
     let fin = "/tmp/69420nasm_in.asm";