enhanced docs

Author: kirjavascript

Cargo.lock

@@ -1,12 +1,13 @@
-[workspace]
-members = [
-]
 [package]
 name = "z80"
 authors = ["Kirjava"]
-version = "0.0.1"
+version = "1.0.0"
 edition = "2021"
 license = "MIT"
+description = "z80 emulator"
+readme = "README.md"
+documentation = "https://docs.rs/z80"
+repository = "https://github.com/kirjavascript/z80"
 
 [lib]
 name = "z80"
@@ -17,3 +18,7 @@ crate-type = ["staticlib", "rlib"]
 
 [profile.test]
 opt-level = 3
+
+[workspace]
+members = [
+]

Cargo.toml

@@ -2,7 +2,9 @@
 
 A fast and accurate instruction-stepped Z80 emulator written in C11 and ported to Rust with c2rust and manual refactoring.
 
-The Rust version appears to run about 25% faster than the C version when benchmarked on my machine.
+The Rust version appears to run about 25% faster than the C version when benchmarked on my machine. 
+
+It still uses unsafe (for now).
 
 This emulator passes both the ZEXDOC and ZEXALL Z80 instruction tests. It has also been verified correct against VisualZ80, and is known to run the entire ColecoVision, SG-1000, Master System, and Game Gear libraries. Additionally, it has been successfully integrated into Mega Drive/Genesis and Neo Geo emulators with unknown (but likely high or perfect) compatibility.
 

README.md

@@ -3,6 +3,40 @@
 #![allow(unused_assignments)]
 #![allow(unused_mut)]
 
+//! A fast and accurate instruction-stepped Z80 emulator written in C11 and ported to Rust
+//!
+//! Basic usage:
+//! ```rust
+//!use z80::{Z80, Z80_io};
+//!
+//!struct IO {
+//!    pub mem: [u8; 0x10000],
+//!}
+//!
+//!impl Z80_io for IO {
+//!    fn read_byte(&self, addr: u16) -> u8 {
+//!        self.mem[addr as usize]
+//!    }
+//!
+//!    fn write_byte(&mut self, addr: u16, value: u8) {
+//!        self.mem[addr as usize] = value;
+//!    }
+//!    fn port_in(&self, _addr: u16) -> u8 { 0xff }
+//!    fn port_out(&mut self, _addr: u16, _value: u8) { }
+//!}
+//!
+//!let mut cpu = Z80::new(IO {
+//!    mem: [0; 0x10000],
+//!});
+//!
+//!for (i, byte) in rom.iter().enumerate() {
+//!    cpu.write_byte(i, *byte);
+//!}
+//!
+//!loop {
+//!    cpu.step();
+//!}
+//!```
 
 mod z80;
 pub use self::z80::*;

lib.rs

@@ -35,16 +35,15 @@ type uint32_t = u32;
 const ASSERT: u32 = 2;
 const PULSE: u32 = 1;
 
+/// Trait for controlling IO behaviour
 pub trait Z80_io {
     fn read_byte(&self, addr: u16) -> u8;
     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);
 }
 
-// pub struct Z80 <T: z80Ctrl>{
-//     pub ctrl: T,
-
+/// Z80 CPU
 pub struct Z80 <T: Z80_io> {
     pub ctrl: T,
     pub pc: uint16_t,
@@ -180,6 +179,12 @@ impl<T: Z80_io> Z80<T> {
         }
         self.ctrl.port_out(addr, value);
     }
+    pub fn read_byte(&self, addr: u16) -> u8 {
+        self.ctrl.read_byte(addr)
+    }
+    pub fn write_byte(&mut self, addr: u16, value: u8) {
+        self.ctrl.write_byte(addr, value);
+    }
     pub fn step(&mut self) -> u32 {
         unsafe { step_s(self) }
     }