From be6555052532fc201d9e1ea38bc3237693e21f65 Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:02:45 -0400 Subject: [PATCH 1/7] fetch, decode, execute loop --- src/bin/main.rs | 13 ++++++++----- src/machine.rs | 24 ++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 6154dee..c264f8f 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -31,10 +31,13 @@ use emu6502::machine; fn main() { let mut machine = machine::Machine::new(); - - println!("A: {}", machine.registers.accumulator); - println!("add_with_carry(1)"); - machine.add_with_carry(1); - println!("A: {}", machine.registers.accumulator); + + for _ in range(0u, 2u) { + let raw_instruction = machine.fetch_instruction(); + let instruction = machine.decode_instruction(raw_instruction); + machine.execute_instruction(instruction); + } + + println!("Ran program, output of Accum is {}", machine.registers.accumulator); } diff --git a/src/machine.rs b/src/machine.rs index 5ae4086..1893ccb 100644 --- a/src/machine.rs +++ b/src/machine.rs @@ -25,6 +25,10 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. +use address::Address; +use address::AddressDiff; +use instruction::Instruction; +use instruction::ADC; use memory::Memory; use registers::{ Registers, Status, StatusArgs }; use registers::{ ps_negative, ps_overflow, ps_zero, ps_carry }; @@ -45,6 +49,26 @@ impl Machine { pub fn reset(&mut self) { *self = Machine::new(); } + + pub fn fetch_instruction(&mut self) -> u8 { + let instr = self.memory.get_byte(&self.registers.program_counter); + self.registers.program_counter.add(&AddressDiff(1)); + instr + } + + pub fn decode_instruction(&mut self, raw_instruction: u8) -> Instruction { + ADC + } + + pub fn execute_instruction(&mut self, instruction: Instruction) { + match instruction { + ADC => { + println!("executing add with carry"); + self.add_with_carry(1); + } + _ => println!("attempting to execute unimplemented instruction") + }; + } // TODO akeeton: Implement binary-coded decimal. pub fn add_with_carry(&mut self, value: i8) { From f2a47f4b005a611f48a7b35a3327b1aa6e968086 Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:07:57 -0400 Subject: [PATCH 2/7] Show impl for machine --- src/bin/main.rs | 2 ++ src/machine.rs | 7 +++++++ 2 files changed, 9 insertions(+) diff --git a/src/bin/main.rs b/src/bin/main.rs index c264f8f..5e04d33 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -39,5 +39,7 @@ fn main() { } println!("Ran program, output of Accum is {}", machine.registers.accumulator); + println!("Machine dump: {}", machine); + } diff --git a/src/machine.rs b/src/machine.rs index 1893ccb..d767ccb 100644 --- a/src/machine.rs +++ b/src/machine.rs @@ -27,6 +27,7 @@ use address::Address; use address::AddressDiff; +use std::fmt; use instruction::Instruction; use instruction::ADC; use memory::Memory; @@ -100,6 +101,12 @@ impl Machine { } } +impl fmt::Show for Machine { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "I am a machine") + } +} + #[test] fn add_with_carry_test() { From f590b2d90c648db851e8059e8f082f5c507f1c5e Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:19:28 -0400 Subject: [PATCH 3/7] program loading --- src/bin/main.rs | 13 ++++++++++--- src/machine.rs | 6 ++++-- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 5e04d33..a26caeb 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -28,18 +28,25 @@ extern crate emu6502; use emu6502::machine; +use emu6502::address::Address; fn main() { let mut machine = machine::Machine::new(); + // "Load" a program + machine.memory.set_byte(&Address(0), 5); + + + // Obviously this will run the full program, just + // executing a finite num of instructions for simplicity + // right now. for _ in range(0u, 2u) { let raw_instruction = machine.fetch_instruction(); let instruction = machine.decode_instruction(raw_instruction); machine.execute_instruction(instruction); } - - println!("Ran program, output of Accum is {}", machine.registers.accumulator); - println!("Machine dump: {}", machine); + + println!("{}", machine); } diff --git a/src/machine.rs b/src/machine.rs index d767ccb..cab4f3d 100644 --- a/src/machine.rs +++ b/src/machine.rs @@ -25,7 +25,6 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. -use address::Address; use address::AddressDiff; use std::fmt; use instruction::Instruction; @@ -53,6 +52,9 @@ impl Machine { pub fn fetch_instruction(&mut self) -> u8 { let instr = self.memory.get_byte(&self.registers.program_counter); + + // Will need smarter logic to fetch the correct number of bytes + // for instruction self.registers.program_counter.add(&AddressDiff(1)); instr } @@ -103,7 +105,7 @@ impl Machine { impl fmt::Show for Machine { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "I am a machine") + write!(f, "Machine Dump:\n\nAccumulator: {}", self.registers.accumulator) } } From 3e2fecec8fa908c7889214d54a355cf09dd509d0 Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:38:07 -0400 Subject: [PATCH 4/7] properly inc PC --- src/bin/main.rs | 3 ++- src/machine.rs | 12 +++++++++--- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index a26caeb..b4c9d88 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -34,7 +34,8 @@ fn main() { let mut machine = machine::Machine::new(); // "Load" a program - machine.memory.set_byte(&Address(0), 5); + machine.memory.set_byte(&Address(0), 0x69); // ADC immediate opcode + machine.memory.set_byte(&Address(1), 0x07); // Immediate operand // Obviously this will run the full program, just diff --git a/src/machine.rs b/src/machine.rs index cab4f3d..775162b 100644 --- a/src/machine.rs +++ b/src/machine.rs @@ -28,7 +28,7 @@ use address::AddressDiff; use std::fmt; use instruction::Instruction; -use instruction::ADC; +use instruction::{ADC, NOP}; use memory::Memory; use registers::{ Registers, Status, StatusArgs }; use registers::{ ps_negative, ps_overflow, ps_zero, ps_carry }; @@ -55,12 +55,15 @@ impl Machine { // Will need smarter logic to fetch the correct number of bytes // for instruction - self.registers.program_counter.add(&AddressDiff(1)); + self.registers.program_counter = self.registers.program_counter + AddressDiff(1); instr } pub fn decode_instruction(&mut self, raw_instruction: u8) -> Instruction { - ADC + match raw_instruction { + 0x69 => ADC, + _ => NOP + } } pub fn execute_instruction(&mut self, instruction: Instruction) { @@ -68,6 +71,9 @@ impl Machine { ADC => { println!("executing add with carry"); self.add_with_carry(1); + }, + NOP => { + println!("nop instr"); } _ => println!("attempting to execute unimplemented instruction") }; From 3563f6362c495b1299028069a42209f1db75cfb8 Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:40:58 -0400 Subject: [PATCH 5/7] get immediate operand when opcode is ADC Immediate --- src/instruction.rs | 4 +++- src/machine.rs | 14 +++++++------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/instruction.rs b/src/instruction.rs index 44025df..fe4c93c 100644 --- a/src/instruction.rs +++ b/src/instruction.rs @@ -48,7 +48,9 @@ pub enum Instruction // NV BDIZC A X Y S PC M // // | outputs | inputs -{ ADC // ADd with Carry................ | NV ...ZC A = A + M + C +{ + ADC(i8) // ADd with Carry................ | NV ...ZC A = A + M + C + , AND // logical AND (bitwise)......... | N. ...Z. A = A && M , ASL // Arithmetic Shift Left......... | N. ...ZC A = M << 1 , BCC // Branch if Carry Clear......... | .. ..... PC = !C diff --git a/src/machine.rs b/src/machine.rs index 775162b..5886425 100644 --- a/src/machine.rs +++ b/src/machine.rs @@ -50,27 +50,27 @@ impl Machine { *self = Machine::new(); } - pub fn fetch_instruction(&mut self) -> u8 { + pub fn fetch_instruction(&mut self) -> i8 { let instr = self.memory.get_byte(&self.registers.program_counter); // Will need smarter logic to fetch the correct number of bytes // for instruction self.registers.program_counter = self.registers.program_counter + AddressDiff(1); - instr - } + instr as i8 + } - pub fn decode_instruction(&mut self, raw_instruction: u8) -> Instruction { + pub fn decode_instruction(&mut self, raw_instruction: i8) -> Instruction { match raw_instruction { - 0x69 => ADC, + 0x69 => ADC(self.fetch_instruction()), _ => NOP } } pub fn execute_instruction(&mut self, instruction: Instruction) { match instruction { - ADC => { + ADC(immediate) => { println!("executing add with carry"); - self.add_with_carry(1); + self.add_with_carry(immediate); }, NOP => { println!("nop instr"); From 9940517c3b89c0aed0d444786d3c0e8d9dddd677 Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:42:52 -0400 Subject: [PATCH 6/7] program 2 adc instructions --- src/bin/main.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index b4c9d88..00dc4f7 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -36,7 +36,8 @@ fn main() { // "Load" a program machine.memory.set_byte(&Address(0), 0x69); // ADC immediate opcode machine.memory.set_byte(&Address(1), 0x07); // Immediate operand - + machine.memory.set_byte(&Address(2), 0x69); // ADC immediate opcode + machine.memory.set_byte(&Address(3), 0x08); // ADC immediate opcode // Obviously this will run the full program, just // executing a finite num of instructions for simplicity From 59132d0d8d0a97d34dc46bc2774c8c5996b6592c Mon Sep 17 00:00:00 2001 From: Alex Weisberger Date: Wed, 1 Oct 2014 18:43:57 -0400 Subject: [PATCH 7/7] Formatting --- src/instruction.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/instruction.rs b/src/instruction.rs index fe4c93c..fac9cd4 100644 --- a/src/instruction.rs +++ b/src/instruction.rs @@ -49,7 +49,7 @@ pub enum Instruction // // | outputs | inputs { - ADC(i8) // ADd with Carry................ | NV ...ZC A = A + M + C + ADC(i8) // ADd with Carry............ | NV ...ZC A = A + M + C , AND // logical AND (bitwise)......... | N. ...Z. A = A && M , ASL // Arithmetic Shift Left......... | N. ...ZC A = M << 1