Add registers

src/chip8.rs

@@ -1,6 +1,7 @@
 const MEMORY_SIZE: usize = 4096;
 const WIDTH: u32 = 64;
 const HEIGHT: u32 = 32;
+const DATA_REGISTERS: usize = 16;
 
 pub const SCALE_FACTOR: u32 = 10;
 pub const WINDOW_WIDTH: u32 = WIDTH * SCALE_FACTOR;
@@ -8,14 +9,78 @@ pub const WINDOW_HEIGHT: u32 = HEIGHT * SCALE_FACTOR;
 
 type Memory = [u8; MEMORY_SIZE];
 
+pub enum Register {
+    V0,
+    V1,
+    V2,
+    V3,
+    V4,
+    V5,
+    V6,
+    V7,
+    V8,
+    V9,
+    VA,
+    VB,
+    VC,
+    VD,
+    VE,
+    VF,
+    I,
+    DT,
+    ST,
+    PC,
+    SP,
+}
+
+struct Registers {
+    data: [u8; DATA_REGISTERS],
+    i: u16,
+    delay_timer: u8,
+    sound_timer: u8,
+    pc: u16,
+    sp: u8,
+}
+
 pub struct Chip8 {
     memory: Memory,
+    registers: Registers,
+}
+
+fn data_register_to_index(register: Register) -> usize {
+    match register {
+        Register::V0 => 0,
+        Register::V1 => 1,
+        Register::V2 => 2,
+        Register::V3 => 3,
+        Register::V4 => 4,
+        Register::V5 => 5,
+        Register::V6 => 6,
+        Register::V7 => 7,
+        Register::V8 => 8,
+        Register::V9 => 9,
+        Register::VA => 10,
+        Register::VB => 11,
+        Register::VC => 12,
+        Register::VD => 13,
+        Register::VE => 14,
+        Register::VF => 15,
+        _ => panic!("invalid data register"),
+    }
 }
 
 impl Chip8 {
     pub fn new() -> Chip8 {
         Chip8 {
             memory: [0; MEMORY_SIZE],
+            registers: Registers {
+                data: [0; DATA_REGISTERS],
+                i: 0,
+                delay_timer: 0,
+                sound_timer: 0,
+                pc: 0,
+                sp: 0,
+            },
         }
     }
 
@@ -26,6 +91,28 @@ impl Chip8 {
     pub fn memory_get(&self, index: usize) -> u8 {
         self.memory[index]
     }
+
+    pub fn register_set(&mut self, register: Register, value: u16) -> () {
+        match register {
+            Register::I => self.registers.i = value,
+            Register::DT => self.registers.delay_timer = value as u8,
+            Register::ST => self.registers.sound_timer = value as u8,
+            Register::PC => self.registers.pc = value,
+            Register::SP => self.registers.sp = value as u8,
+            _ => self.registers.data[data_register_to_index(register)] = value as u8,
+        }
+    }
+
+    pub fn register_get(&mut self, register: Register) -> u16 {
+        match register {
+            Register::I => self.registers.i,
+            Register::DT => self.registers.delay_timer as u16,
+            Register::ST => self.registers.sound_timer as u16,
+            Register::PC => self.registers.pc,
+            Register::SP => self.registers.sp as u16,
+            _ => self.registers.data[data_register_to_index(register)] as u16,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -33,7 +120,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn it_has_the_correct_size() {
+    fn it_has_the_correct_memory_size() {
         assert_eq!(Chip8::new().memory.len(), MEMORY_SIZE);
     }
 
@@ -50,4 +137,37 @@ mod tests {
         chip8.memory_set(2, 42);
         assert_eq!(chip8.memory_get(2), 42);
     }
+
+    #[test]
+    fn it_has_the_correct_number_of_data_registers() {
+        assert_eq!(Chip8::new().registers.data.len(), DATA_REGISTERS);
+    }
+
+    #[test]
+    fn it_can_write_data_registers() {
+        let mut chip8 = Chip8::new();
+        chip8.register_set(Register::VA, 42);
+        assert_eq!(chip8.registers.data[10], 42);
+    }
+
+    #[test]
+    fn it_can_read_data_registers() {
+        let mut chip8 = Chip8::new();
+        chip8.register_set(Register::VA, 42);
+        assert_eq!(chip8.register_get(Register::VA), 42);
+    }
+
+    #[test]
+    fn it_can_write_special_registers() {
+        let mut chip8 = Chip8::new();
+        chip8.register_set(Register::PC, 42);
+        assert_eq!(chip8.registers.pc, 42);
+    }
+
+    #[test]
+    fn it_can_read_special_registers() {
+        let mut chip8 = Chip8::new();
+        chip8.register_set(Register::PC, 42);
+        assert_eq!(chip8.register_get(Register::PC), 42);
+    }
 }

src/main.rs

@@ -8,10 +8,6 @@ mod chip8;
 const EMULATOR_WINDOW_TITLE: &str = "Rust CHIP-8";
 
 fn main() -> Result<(), String> {
-    let mut chip8 = chip8::Chip8::new();
-    chip8.memory_set(42, 42);
-    println!("{}", &chip8.memory_get(42));
-
     let sdl_context = sdl2::init()?;
     let video_subsystem = sdl_context.video()?;