wip: opcode lookup table

Author: nathanleiby

src/core.rs

@@ -1,4 +1,8 @@
-use crate::{bus::Bus, rom::Rom};
+use crate::{
+    bus::Bus,
+    ops::{parse_opcode, OpName},
+    rom::Rom,
+};
 
 /// CPU (Central Processing Unit)
 /// The NES uses  2A03, which is a modified version of the 6502 chip.
@@ -223,42 +227,53 @@ impl Cpu {
         loop {
             callback(self);
 
-            let op = self.mem_read(self.pc);
+            let opcode = self.mem_read(self.pc);
             self.pc += 1;
-            match op {
-                // LDA
-                0xA9 => {
-                    self.lda(&AddressingMode::Immediate);
-                    self.pc += 1;
-                }
-                0xA5 => {
-                    self.lda(&AddressingMode::ZeroPage);
-                    self.pc += 1;
-                }
-                0xB5 => {
-                    self.lda(&AddressingMode::ZeroPageX);
-                    self.pc += 1;
-                }
-                0xAD => {
-                    self.lda(&AddressingMode::Absolute);
-                    self.pc += 2;
-                }
-                0xBD => {
-                    self.lda(&AddressingMode::AbsoluteX);
-                    self.pc += 2;
-                }
-                0xB9 => {
-                    self.lda(&AddressingMode::AbsoluteY);
-                    self.pc += 2;
-                }
-                0xA1 => {
-                    self.lda(&AddressingMode::IndirectX);
-                    self.pc += 1;
-                }
-                0xB1 => {
-                    self.lda(&AddressingMode::IndirectY);
-                    self.pc += 1;
+
+            if let Some(op) = parse_opcode(opcode) {
+                match op.0 {
+                    OpName::LDA => self.lda(&op.2),
+                    _ => todo!(),
                 }
+                self.pc += op.1;
+
+                continue;
+            }
+
+            match opcode {
+                // // LDA
+                // 0xA9 => {
+                //     self.lda(&AddressingMode::Immediate);
+                //     self.pc += 1;
+                // }
+                // 0xA5 => {
+                //     self.lda(&AddressingMode::ZeroPage);
+                //     self.pc += 1;
+                // }
+                // 0xB5 => {
+                //     self.lda(&AddressingMode::ZeroPageX);
+                //     self.pc += 1;
+                // }
+                // 0xAD => {
+                //     self.lda(&AddressingMode::Absolute);
+                //     self.pc += 2;
+                // }
+                // 0xBD => {
+                //     self.lda(&AddressingMode::AbsoluteX);
+                //     self.pc += 2;
+                // }
+                // 0xB9 => {
+                //     self.lda(&AddressingMode::AbsoluteY);
+                //     self.pc += 2;
+                // }
+                // 0xA1 => {
+                //     self.lda(&AddressingMode::IndirectX);
+                //     self.pc += 1;
+                // }
+                // 0xB1 => {
+                //     self.lda(&AddressingMode::IndirectY);
+                //     self.pc += 1;
+                // }
 
                 // LDX
                 0xA2 => {
@@ -806,7 +821,7 @@ impl Cpu {
                 0xF8 => self.set_flag(Flag::Decimal, true),
 
                 _ => {
-                    println!("Op {:#04x} not yet implemented", op);
+                    println!("Op {:#04x} not yet implemented", opcode);
                     todo!();
                 }
             }

src/main.rs

@@ -7,6 +7,7 @@ use std::time::Duration;
 
 mod bus;
 mod core;
+mod ops;
 mod rom;
 
 use rand::random;

src/ops.rs

@@ -0,0 +1,45 @@
+use core::fmt;
+
+use crate::core::AddressingMode;
+
+// TODO: Stringify these
+#[derive(Debug, PartialEq, Eq)]
+pub enum OpName {
+    LDA,
+
+    TODO, // TODO
+}
+
+impl fmt::Display for OpName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+pub struct Op(pub OpName, pub u16, pub AddressingMode);
+
+pub fn parse_opcode(code: u8) -> Option<Op> {
+    let op = match code {
+        0xA9 => Op(OpName::LDA, 2, AddressingMode::Immediate),
+        0xA5 => Op(OpName::LDA, 2, AddressingMode::ZeroPage),
+        0xB5 => Op(OpName::LDA, 2, AddressingMode::ZeroPageX),
+        0xAD => Op(OpName::LDA, 3, AddressingMode::Absolute),
+        0xBD => Op(OpName::LDA, 3, AddressingMode::AbsoluteX),
+        0xB9 => Op(OpName::LDA, 3, AddressingMode::AbsoluteY),
+        0xA1 => Op(OpName::LDA, 2, AddressingMode::IndirectX),
+        0xB1 => Op(OpName::LDA, 2, AddressingMode::IndirectY),
+        // 0xA1 => Op(OpName::LDA, 3, AddressingMode::AbsoluteY),
+        // 0xB1 => Op(OpName::LDA, 3, AddressingMode::AbsoluteY),
+        // 0xA2 => {
+        //     self.ldx(&AddressingMode::Immediate);
+        //     self.pc += 1;
+        // }
+        _ => Op(OpName::TODO, 0, AddressingMode::None),
+    };
+
+    if op.0 == OpName::TODO {
+        None
+    } else {
+        Some(op)
+    }
+}