first set of tests pass

Author: kirjavascript

lib.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-#![allow(mutable_transmutes)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]

z80.rs

@@ -12,6 +12,8 @@ pub trait z80Ctrl {
     fn write_byte(&mut self, addr: u16, value: u8);
     fn port_in(&self, addr: u16) -> u8;
     fn port_out(&mut self, addr: u16, value: u8);
+    #[cfg(test)]
+    fn test_finished(&self) -> bool;
 }
 
 #[derive(BitfieldStruct)]
@@ -90,7 +92,7 @@ impl z80 {
             c2rust_padding: [0; 6],
         }
     }
-    fn init(&mut self) {
+    pub fn init(&mut self) {
         self.pc = 0 as i32 as uint16_t;
         self.sp = 0xffff as i32 as uint16_t;
         self.ix = 0 as i32 as uint16_t;
@@ -115,6 +117,9 @@ impl z80 {
         self.nmi_pending = 0 as i32 as uint8_t;
         self.irq_data = 0 as i32 as uint8_t;
     }
+    pub fn step(&mut self) -> u32 {
+        unsafe { z80_step_s(self) }
+    }
 }
 
 #[derive(Copy, Clone)]
@@ -1066,10 +1071,6 @@ pub unsafe extern "C" fn z80_set_sp(z: *mut z80, mut sp: uint16_t) {
     (*z).sp = sp;
 }
 #[no_mangle]
-pub unsafe extern "C" fn z80_step(z: *mut z80) -> u32 {
-    return z80_step_s(z);
-}
-#[no_mangle]
 pub unsafe extern "C" fn z80_step_n(
     z: *mut z80,
     mut cycles: u32,

z80_tests.rs

@@ -1,7 +1,8 @@
 use crate::z80::{z80, z80Ctrl};
 
 struct Memory {
-    mem: [u8; 0x10000],
+    pub mem: [u8; 0x10000],
+    pub test_finished: bool,
 }
 
 impl z80Ctrl for Memory {
@@ -13,17 +14,58 @@ impl z80Ctrl for Memory {
         self.mem[addr as usize] = value;
     }
     fn port_in(&self, addr: u16) -> u8 {
-        0
+        0xff
     }
     fn port_out(&mut self, addr: u16, value: u8) {
+        self.test_finished = true;
+    }
+    fn test_finished(&self) -> bool {
+        self.test_finished
     }
 }
 
-#[test]
-pub fn main() {
-    let memory = Box::new(Memory {
+fn run_test(rom: &[u8], cyc_expected: u64) {
+    let mut memory = Box::new(Memory {
         mem: [0; 0x10000],
+        test_finished: false,
     });
-    let cpu = z80::new(memory);
 
+    for (i, byte) in rom.iter().enumerate() {
+        memory.mem[0x100 + i] = *byte;
+    }
+
+    let mut cyc: u64 = 0;
+        println!("{:#?}", 1);
+
+    let mut cpu = z80::new(memory);
+    cpu.init();
+    cpu.pc = 0x100;
+    cpu.ctrl.write_byte(0,0xd3);
+    cpu.ctrl.write_byte(1,0);
+    cpu.ctrl.write_byte(5,0xdb);
+    cpu.ctrl.write_byte(6,0);
+    cpu.ctrl.write_byte(7,0xc9);
+
+    let mut nb_instructions: u64 = 0;
+    while !cpu.ctrl.test_finished() {
+        nb_instructions += 1;
+        cyc = cyc.wrapping_add(cpu.step().into());
+    }
+    let diff = cyc_expected.wrapping_sub(cyc);
+    println!(
+        "\n*** {} instructions executed on {} cycles (expected={}, diff={})\n\n",
+        nb_instructions,
+        cyc,
+        cyc_expected,
+        diff,
+    );
+
+    assert_eq!(cyc, cyc_expected);
+}
+
+#[test]
+pub fn main() {
+    run_test(include_bytes!("./roms/prelim.com"), 8721);
+    run_test(include_bytes!("./roms/zexdoc.cim"), 46734978649);
+    run_test(include_bytes!("roms/zexall.cim"), 46734978649);
 }