From a9697e6b79debc801916643da777b015092380cc Mon Sep 17 00:00:00 2001 From: Noppadet Vivatchotikul Date: Thu, 25 Oct 2018 22:07:16 +0700 Subject: [PATCH 1/8] remove warning --- src/bin/{main.rs => mos6502.rs} | 0 src/cpu.rs | 60 ++++++++++++++++----------------- 2 files changed, 30 insertions(+), 30 deletions(-) rename src/bin/{main.rs => mos6502.rs} (100%) diff --git a/src/bin/main.rs b/src/bin/mos6502.rs similarity index 100% rename from src/bin/main.rs rename to src/bin/mos6502.rs diff --git a/src/cpu.rs b/src/cpu.rs index 2bdca43..b1e1469 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -776,7 +776,7 @@ mod tests { #[test] fn add_with_carry_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.add_with_carry(1); assert_eq!(CPU.registers.accumulator, 1); @@ -799,7 +799,7 @@ mod tests { assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.add_with_carry(127); assert_eq!(CPU.registers.accumulator, 127); @@ -830,7 +830,7 @@ mod tests { assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.add_with_carry(127); assert_eq!(CPU.registers.accumulator, 127); @@ -849,7 +849,7 @@ mod tests { #[test] fn and_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.registers.accumulator = 0; CPU.and(-1); @@ -878,7 +878,7 @@ mod tests { #[test] fn subtract_with_carry_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); CPU.registers.accumulator = 0; @@ -938,7 +938,7 @@ mod tests { #[test] fn decrement_memory_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); let addr = Address(0xA1B2); CPU.memory.set_byte(addr, 5); @@ -970,7 +970,7 @@ mod tests { fn logical_shift_right_test() { // Testing UseImplied version (which targets the accumulator) only, for now - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0))); CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); assert_eq!(CPU.registers.accumulator, 0); @@ -1006,7 +1006,7 @@ mod tests { #[test] fn dec_x_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.dec_x(); assert_eq!(CPU.registers.index_x, -1); @@ -1051,7 +1051,7 @@ mod tests { #[test] fn jump_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); let addr = Address(0xA1B1); CPU.jump(addr); @@ -1060,7 +1060,7 @@ mod tests { #[test] fn branch_if_carry_clear_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); CPU.branch_if_carry_clear(Address(0xABCD)); @@ -1073,7 +1073,7 @@ mod tests { #[test] fn branch_if_carry_set_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); CPU.branch_if_carry_set(Address(0xABCD)); @@ -1086,7 +1086,7 @@ mod tests { #[test] fn branch_if_equal_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.branch_if_equal(Address(0xABCD)); assert_eq!(CPU.registers.program_counter, Address(0)); @@ -1099,7 +1099,7 @@ mod tests { #[test] fn branch_if_minus_test() { { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); let registers_before = CPU.registers; CPU.branch_if_minus(Address(0xABCD)); @@ -1108,7 +1108,7 @@ mod tests { } { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.registers.status.or(PS_NEGATIVE); let registers_before = CPU.registers; @@ -1121,7 +1121,7 @@ mod tests { #[test] fn branch_if_positive_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.registers.status.insert(PS_NEGATIVE); CPU.branch_if_positive(Address(0xABCD)); @@ -1134,7 +1134,7 @@ mod tests { #[test] fn branch_if_overflow_clear_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.registers.status.insert(PS_OVERFLOW); CPU.branch_if_overflow_clear(Address(0xABCD)); @@ -1147,7 +1147,7 @@ mod tests { #[test] fn branch_if_overflow_set_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.branch_if_overflow_set(Address(0xABCD)); assert_eq!(CPU.registers.program_counter, Address(0)); @@ -1160,13 +1160,13 @@ mod tests { #[cfg(test)] fn compare_test_helper(compare: &mut F, load_instruction: Instruction) where - F: FnMut(&mut CPU, u8), + F: FnMut(&mut cpu, u8), { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); - compare(&mut CPU, 127); + compare(&mut cpu, 127); assert!(CPU.registers.status.contains(PS_ZERO)); assert!(CPU.registers.status.contains(PS_CARRY)); assert!(!CPU.registers.status.contains(PS_NEGATIVE)); @@ -1174,7 +1174,7 @@ mod tests { CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); - compare(&mut CPU, 1); + compare(&mut cpu, 1); assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(CPU.registers.status.contains(PS_CARRY)); assert!(!CPU.registers.status.contains(PS_NEGATIVE)); @@ -1182,7 +1182,7 @@ mod tests { CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); - compare(&mut CPU, 2); + compare(&mut cpu, 2); assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(CPU.registers.status.contains(PS_NEGATIVE)); @@ -1190,7 +1190,7 @@ mod tests { CPU.execute_instruction((load_instruction, OpInput::UseImmediate(20))); - compare(&mut CPU, -50i8 as u8); + compare(&mut cpu, -50i8 as u8); assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!CPU.registers.status.contains(PS_NEGATIVE)); @@ -1198,7 +1198,7 @@ mod tests { CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); - compare(&mut CPU, -1i8 as u8); + compare(&mut cpu, -1i8 as u8); assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!CPU.registers.status.contains(PS_NEGATIVE)); @@ -1206,7 +1206,7 @@ mod tests { CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); - compare(&mut CPU, -128i8 as u8); + compare(&mut cpu, -128i8 as u8); assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(CPU.registers.status.contains(PS_NEGATIVE)); @@ -1215,7 +1215,7 @@ mod tests { #[test] fn compare_with_a_register_test() { compare_test_helper( - &mut |CPU: &mut CPU, val: u8| { + &mut |CPU: &mut cpu, val: u8| { CPU.compare_with_a_register(val); }, Instruction::LDA, @@ -1225,7 +1225,7 @@ mod tests { #[test] fn compare_with_x_register_test() { compare_test_helper( - &mut |CPU: &mut CPU, val: u8| { + &mut |CPU: &mut cpu, val: u8| { CPU.compare_with_x_register(val); }, Instruction::LDX, @@ -1235,7 +1235,7 @@ mod tests { #[test] fn compare_with_y_register_test() { compare_test_helper( - &mut |CPU: &mut CPU, val: u8| { + &mut |CPU: &mut cpu, val: u8| { CPU.compare_with_y_register(val); }, Instruction::LDY, @@ -1244,7 +1244,7 @@ mod tests { #[test] fn exclusive_or_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); for a_before in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) { @@ -1272,7 +1272,7 @@ mod tests { #[test] fn inclusive_or_test() { - let mut CPU = CPU::new(); + let mut cpu = CPU::new(); for a_before in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) { From c440637adb9ac41e52052071c7221fb269253ac7 Mon Sep 17 00:00:00 2001 From: Noppadet Vivatchotikul Date: Thu, 25 Oct 2018 22:35:00 +0700 Subject: [PATCH 2/8] fix variable --- src/cpu.rs | 580 ++++++++++++++++++++++++++--------------------------- 1 file changed, 290 insertions(+), 290 deletions(-) diff --git a/src/cpu.rs b/src/cpu.rs index b1e1469..c2e38e4 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -778,162 +778,162 @@ mod tests { fn add_with_carry_test() { let mut cpu = CPU::new(); - CPU.add_with_carry(1); - assert_eq!(CPU.registers.accumulator, 1); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(1); + assert_eq!(cpu.registers.accumulator, 1); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.add_with_carry(-1); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(-1); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.add_with_carry(1); - assert_eq!(CPU.registers.accumulator, 2); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(1); + assert_eq!(cpu.registers.accumulator, 2); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); let mut cpu = CPU::new(); - CPU.add_with_carry(127); - assert_eq!(CPU.registers.accumulator, 127); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(127); + assert_eq!(cpu.registers.accumulator, 127); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.add_with_carry(-127); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(-127); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.registers.status.remove(PS_CARRY); - CPU.add_with_carry(-128); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.registers.status.remove(PS_CARRY); + cpu.add_with_carry(-128); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.add_with_carry(127); - assert_eq!(CPU.registers.accumulator, -1); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(127); + assert_eq!(cpu.registers.accumulator, -1); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); let mut cpu = CPU::new(); - CPU.add_with_carry(127); - assert_eq!(CPU.registers.accumulator, 127); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.add_with_carry(127); + assert_eq!(cpu.registers.accumulator, 127); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.add_with_carry(1); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); + cpu.add_with_carry(1); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true); } #[test] fn and_test() { let mut cpu = CPU::new(); - CPU.registers.accumulator = 0; - CPU.and(-1); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.registers.accumulator = 0; + cpu.and(-1); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.registers.accumulator = -1; - CPU.and(0); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.registers.accumulator = -1; + cpu.and(0); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.registers.accumulator = -1; - CPU.and(0x0f); - assert_eq!(CPU.registers.accumulator, 0x0f); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.registers.accumulator = -1; + cpu.and(0x0f); + assert_eq!(cpu.registers.accumulator, 0x0f); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.registers.accumulator = -1; - CPU.and(-128); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); + cpu.registers.accumulator = -1; + cpu.and(-128); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); } #[test] fn subtract_with_carry_test() { let mut cpu = CPU::new(); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.registers.accumulator = 0; + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.registers.accumulator = 0; - CPU.subtract_with_carry(1); - assert_eq!(CPU.registers.accumulator, -1); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.subtract_with_carry(1); + assert_eq!(cpu.registers.accumulator, -1); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.registers.accumulator = -128; - CPU.subtract_with_carry(1); - assert_eq!(CPU.registers.accumulator, 127); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.registers.accumulator = -128; + cpu.subtract_with_carry(1); + assert_eq!(cpu.registers.accumulator, 127); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.registers.accumulator = 127; - CPU.subtract_with_carry(-1); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.registers.accumulator = 127; + cpu.subtract_with_carry(-1); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true); - CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); - CPU.registers.accumulator = -64; - CPU.subtract_with_carry(64); - assert_eq!(CPU.registers.accumulator, 127); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); + cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied)); + cpu.registers.accumulator = -64; + cpu.subtract_with_carry(64); + assert_eq!(cpu.registers.accumulator, 127); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.registers.accumulator = 0; - CPU.subtract_with_carry(-128); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.registers.accumulator = 0; + cpu.subtract_with_carry(-128); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true); - CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); - CPU.registers.accumulator = 0; - CPU.subtract_with_carry(127); - assert_eq!(CPU.registers.accumulator, -128); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied)); + cpu.registers.accumulator = 0; + cpu.subtract_with_carry(127); + assert_eq!(cpu.registers.accumulator, -128); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); } #[test] @@ -941,29 +941,29 @@ mod tests { let mut cpu = CPU::new(); let addr = Address(0xA1B2); - CPU.memory.set_byte(addr, 5); + cpu.memory.set_byte(addr, 5); - CPU.decrement_memory(addr); - assert_eq!(CPU.memory.get_byte(addr), 4); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.decrement_memory(addr); + assert_eq!(cpu.memory.get_byte(addr), 4); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.decrement_memory(addr); - assert_eq!(CPU.memory.get_byte(addr), 3); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.decrement_memory(addr); + assert_eq!(cpu.memory.get_byte(addr), 3); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.decrement_memory(addr); - CPU.decrement_memory(addr); - CPU.decrement_memory(addr); - assert_eq!(CPU.memory.get_byte(addr), 0); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); + cpu.decrement_memory(addr); + cpu.decrement_memory(addr); + cpu.decrement_memory(addr); + assert_eq!(cpu.memory.get_byte(addr), 0); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); - CPU.decrement_memory(addr); - assert_eq!(CPU.memory.get_byte(addr) as i8, -1); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); + cpu.decrement_memory(addr); + assert_eq!(cpu.memory.get_byte(addr) as i8, -1); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); } #[test] @@ -971,82 +971,82 @@ mod tests { // Testing UseImplied version (which targets the accumulator) only, for now let mut cpu = CPU::new(); - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0))); - CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0))); + cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied)); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1))); - CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); - assert_eq!(CPU.registers.accumulator, 0); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1))); + cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied)); + assert_eq!(cpu.registers.accumulator, 0); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255))); - CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); - assert_eq!(CPU.registers.accumulator, 0x7F); - assert_eq!(CPU.registers.status.contains(PS_CARRY), true); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255))); + cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied)); + assert_eq!(cpu.registers.accumulator, 0x7F); + assert_eq!(cpu.registers.status.contains(PS_CARRY), true); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254))); - CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); - assert_eq!(CPU.registers.accumulator, 0x7F); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254))); + cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied)); + assert_eq!(cpu.registers.accumulator, 0x7F); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); } #[test] fn dec_x_test() { let mut cpu = CPU::new(); - CPU.dec_x(); - assert_eq!(CPU.registers.index_x, -1); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.dec_x(); + assert_eq!(cpu.registers.index_x, -1); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.dec_x(); - assert_eq!(CPU.registers.index_x, -2); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.dec_x(); + assert_eq!(cpu.registers.index_x, -2); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.load_x_register(5); - CPU.dec_x(); - assert_eq!(CPU.registers.index_x, 4); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.load_x_register(5); + cpu.dec_x(); + assert_eq!(cpu.registers.index_x, 4); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.dec_x(); - CPU.dec_x(); - CPU.dec_x(); - CPU.dec_x(); + cpu.dec_x(); + cpu.dec_x(); + cpu.dec_x(); + cpu.dec_x(); - assert_eq!(CPU.registers.index_x, 0); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), true); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + assert_eq!(cpu.registers.index_x, 0); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), true); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); - CPU.dec_x(); - assert_eq!(CPU.registers.index_x, -1); - assert_eq!(CPU.registers.status.contains(PS_CARRY), false); - assert_eq!(CPU.registers.status.contains(PS_ZERO), false); - assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); - assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); + cpu.dec_x(); + assert_eq!(cpu.registers.index_x, -1); + assert_eq!(cpu.registers.status.contains(PS_CARRY), false); + assert_eq!(cpu.registers.status.contains(PS_ZERO), false); + assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true); + assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false); } #[test] @@ -1054,68 +1054,68 @@ mod tests { let mut cpu = CPU::new(); let addr = Address(0xA1B1); - CPU.jump(addr); - assert_eq!(CPU.registers.program_counter, addr); + cpu.jump(addr); + assert_eq!(cpu.registers.program_counter, addr); } #[test] fn branch_if_carry_clear_test() { let mut cpu = CPU::new(); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.branch_if_carry_clear(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.branch_if_carry_clear(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); - CPU.branch_if_carry_clear(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied)); + cpu.branch_if_carry_clear(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[test] fn branch_if_carry_set_test() { let mut cpu = CPU::new(); - CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); - CPU.branch_if_carry_set(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied)); + cpu.branch_if_carry_set(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); - CPU.branch_if_carry_set(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied)); + cpu.branch_if_carry_set(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[test] fn branch_if_equal_test() { let mut cpu = CPU::new(); - CPU.branch_if_equal(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.branch_if_equal(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.registers.status.or(PS_ZERO); - CPU.branch_if_equal(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.registers.status.or(PS_ZERO); + cpu.branch_if_equal(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[test] fn branch_if_minus_test() { { let mut cpu = CPU::new(); - let registers_before = CPU.registers; + let registers_before = cpu.registers; - CPU.branch_if_minus(Address(0xABCD)); - assert_eq!(CPU.registers, registers_before); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.branch_if_minus(Address(0xABCD)); + assert_eq!(cpu.registers, registers_before); + assert_eq!(cpu.registers.program_counter, Address(0)); } { let mut cpu = CPU::new(); - CPU.registers.status.or(PS_NEGATIVE); - let registers_before = CPU.registers; + cpu.registers.status.or(PS_NEGATIVE); + let registers_before = cpu.registers; - CPU.branch_if_minus(Address(0xABCD)); - assert_eq!(CPU.registers.status, registers_before.status); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.branch_if_minus(Address(0xABCD)); + assert_eq!(cpu.registers.status, registers_before.status); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } } @@ -1123,38 +1123,38 @@ mod tests { fn branch_if_positive_test() { let mut cpu = CPU::new(); - CPU.registers.status.insert(PS_NEGATIVE); - CPU.branch_if_positive(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.registers.status.insert(PS_NEGATIVE); + cpu.branch_if_positive(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.registers.status.remove(PS_NEGATIVE); - CPU.branch_if_positive(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.registers.status.remove(PS_NEGATIVE); + cpu.branch_if_positive(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[test] fn branch_if_overflow_clear_test() { let mut cpu = CPU::new(); - CPU.registers.status.insert(PS_OVERFLOW); - CPU.branch_if_overflow_clear(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.registers.status.insert(PS_OVERFLOW); + cpu.branch_if_overflow_clear(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.registers.status.remove(PS_OVERFLOW); - CPU.branch_if_overflow_clear(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.registers.status.remove(PS_OVERFLOW); + cpu.branch_if_overflow_clear(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[test] fn branch_if_overflow_set_test() { let mut cpu = CPU::new(); - CPU.branch_if_overflow_set(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0)); + cpu.branch_if_overflow_set(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0)); - CPU.registers.status.insert(PS_OVERFLOW); - CPU.branch_if_overflow_set(Address(0xABCD)); - assert_eq!(CPU.registers.program_counter, Address(0xABCD)); + cpu.registers.status.insert(PS_OVERFLOW); + cpu.branch_if_overflow_set(Address(0xABCD)); + assert_eq!(cpu.registers.program_counter, Address(0xABCD)); } #[cfg(test)] @@ -1164,59 +1164,59 @@ mod tests { { let mut cpu = CPU::new(); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127))); compare(&mut cpu, 127); - assert!(CPU.registers.status.contains(PS_ZERO)); - assert!(CPU.registers.status.contains(PS_CARRY)); - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(cpu.registers.status.contains(PS_ZERO)); + assert!(cpu.registers.status.contains(PS_CARRY)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127))); compare(&mut cpu, 1); - assert!(!CPU.registers.status.contains(PS_ZERO)); - assert!(CPU.registers.status.contains(PS_CARRY)); - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_ZERO)); + assert!(cpu.registers.status.contains(PS_CARRY)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(1))); compare(&mut cpu, 2); - assert!(!CPU.registers.status.contains(PS_ZERO)); - assert!(!CPU.registers.status.contains(PS_CARRY)); - assert!(CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_CARRY)); + assert!(cpu.registers.status.contains(PS_NEGATIVE)); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(20))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(20))); compare(&mut cpu, -50i8 as u8); - assert!(!CPU.registers.status.contains(PS_ZERO)); - assert!(!CPU.registers.status.contains(PS_CARRY)); - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_CARRY)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(1))); compare(&mut cpu, -1i8 as u8); - assert!(!CPU.registers.status.contains(PS_ZERO)); - assert!(!CPU.registers.status.contains(PS_CARRY)); - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_CARRY)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); - CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); + cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127))); compare(&mut cpu, -128i8 as u8); - assert!(!CPU.registers.status.contains(PS_ZERO)); - assert!(!CPU.registers.status.contains(PS_CARRY)); - assert!(CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_CARRY)); + assert!(cpu.registers.status.contains(PS_NEGATIVE)); } #[test] fn compare_with_a_register_test() { compare_test_helper( &mut |CPU: &mut cpu, val: u8| { - CPU.compare_with_a_register(val); + cpu.compare_with_a_register(val); }, Instruction::LDA, ); @@ -1226,7 +1226,7 @@ mod tests { fn compare_with_x_register_test() { compare_test_helper( &mut |CPU: &mut cpu, val: u8| { - CPU.compare_with_x_register(val); + cpu.compare_with_x_register(val); }, Instruction::LDX, ); @@ -1236,7 +1236,7 @@ mod tests { fn compare_with_y_register_test() { compare_test_helper( &mut |CPU: &mut cpu, val: u8| { - CPU.compare_with_y_register(val); + cpu.compare_with_y_register(val); }, Instruction::LDY, ); @@ -1248,23 +1248,23 @@ mod tests { for a_before in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) { - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); - CPU.exclusive_or(val); + cpu.exclusive_or(val); let a_after = a_before ^ val; - assert_eq!(CPU.registers.accumulator, a_after as i8); + assert_eq!(cpu.registers.accumulator, a_after as i8); if a_after == 0 { - assert!(CPU.registers.status.contains(PS_ZERO)); + assert!(cpu.registers.status.contains(PS_ZERO)); } else { - assert!(!CPU.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_ZERO)); } if (a_after as i8) < 0 { - assert!(CPU.registers.status.contains(PS_NEGATIVE)); + assert!(cpu.registers.status.contains(PS_NEGATIVE)); } else { - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); } } } @@ -1276,23 +1276,23 @@ mod tests { for a_before in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) { - CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); + cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); - CPU.inclusive_or(val); + cpu.inclusive_or(val); let a_after = a_before | val; - assert_eq!(CPU.registers.accumulator, a_after as i8); + assert_eq!(cpu.registers.accumulator, a_after as i8); if a_after == 0 { - assert!(CPU.registers.status.contains(PS_ZERO)); + assert!(cpu.registers.status.contains(PS_ZERO)); } else { - assert!(!CPU.registers.status.contains(PS_ZERO)); + assert!(!cpu.registers.status.contains(PS_ZERO)); } if (a_after as i8) < 0 { - assert!(CPU.registers.status.contains(PS_NEGATIVE)); + assert!(cpu.registers.status.contains(PS_NEGATIVE)); } else { - assert!(!CPU.registers.status.contains(PS_NEGATIVE)); + assert!(!cpu.registers.status.contains(PS_NEGATIVE)); } } } From a6c30d0d48a9e3554daee89cd3ce2e9c7647c2fd Mon Sep 17 00:00:00 2001 From: Matthias Endler Date: Thu, 25 Oct 2018 20:12:54 +0200 Subject: [PATCH 3/8] Add usage example --- Cargo.toml | 11 ++-- README.md | 110 +++++++++++++++++++++++++++++++++++++ build.rs | 5 ++ src/bin/main.rs | 140 ----------------------------------------------- tests/skeptic.rs | 1 + 5 files changed, 123 insertions(+), 144 deletions(-) create mode 100644 build.rs delete mode 100644 src/bin/main.rs create mode 100644 tests/skeptic.rs diff --git a/Cargo.toml b/Cargo.toml index 19be059..6ece88e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,16 +32,19 @@ description = "A MOS 6502 Emulator" license = "BSD-3-Clause" version = "0.0.1" authors = ["The 6502-rs Developers"] +build = "build.rs" [lib] # This will look in src/lib.rs name = "mos6502" -[[bin]] -# This will look in src/bin/mos6502.rs -name = "mos6502" - [dependencies] bitflags = "0.9.1" log = "0.3.8" num = "0.1" + +[build-dependencies] +skeptic = "0.13" + +[dev-dependencies] +skeptic = "0.13" diff --git a/README.md b/README.md index 88b84b4..b400b4f 100644 --- a/README.md +++ b/README.md @@ -7,3 +7,113 @@ This started off as a fork of [6502-rs](https://github.com/amw-zero/6502-rs), which seems to be unmaintained at this point. It builds with the latest stable Rust. + +## Usage example + +```rust +extern crate mos6502; + +use mos6502::cpu; +use mos6502::address::Address; + +fn main() { + let mut cpu = cpu::CPU::new(); + + let zero_page_data = [ + // ZeroPage data start + 0x00, + 0x02, // ADC ZeroPage target + 0x00, + 0x04, // ADC ZeroPageX target + 0x00, + 0x00, + 0x00, + 0x00, + 0x10, // ADC IndexedIndirectX address + 0x80, // ADC IndexedIndirectX address + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x08, // ADC IndirectIndexedY address + 0x80, // ADC IndirectIndexedY address + ]; + + let program = [ + // Code start + 0xA9, // LDA Immediate + 0x01, // Immediate operand + 0x69, // ADC Immediate + 0x07, // Immediate operand + 0x65, // ADC ZeroPage + 0x01, // ZeroPage operand + 0xA2, // LDX Immediate + 0x01, // Immediate operand + 0x75, // ADC ZeroPageX + 0x02, // ZeroPageX operand + 0x6D, // ADC Absolute + 0x01, // Absolute operand + 0x80, // Absolute operand + 0xA2, // LDX immediate + 0x08, // Immediate operand + 0x7D, // ADC AbsoluteX + 0x00, // AbsoluteX operand + 0x80, // AbsoluteX operand + 0xA0, // LDY immediate + 0x04, // Immediate operand + 0x79, // ADC AbsoluteY + 0x00, // AbsoluteY operand + 0x80, // AbsoluteY operand + 0xA2, // LDX immediate + 0x05, // Immediate operand + 0x61, // ADC IndexedIndirectX + 0x03, // IndexedIndirectX operand + 0xA0, // LDY immediate + 0x10, // Immediate operand + 0x71, // ADC IndirectIndexedY + 0x0F, // IndirectIndexedY operand + 0xEA, // NOP :) + 0xFF, // Something invalid -- the end! + ]; + + let data: [u8; 25] = [ + 0x00, + 0x09, // ADC Absolute target + 0x00, + 0x00, + 0x40, // ADC AbsoluteY target + 0x00, + 0x00, + 0x00, + 0x11, // ADC AbsoluteX target + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x12, // ADC IndexedIndirectX target + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x06, // ADC IndirectIndexedY target + ]; + + // "Load" a program + cpu.memory.set_bytes(Address(0x0000), &zero_page_data); + cpu.memory.set_bytes(Address(0x4000), &program); + cpu.memory.set_bytes(Address(0x8000), &data); + + cpu.registers.program_counter = Address(0x4000); + + cpu.run(); + + println!("{:?}", cpu); +} +``` diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..a780b3d --- /dev/null +++ b/build.rs @@ -0,0 +1,5 @@ +extern crate skeptic; + +fn main() { + skeptic::generate_doc_tests(&["README.md"]); +} diff --git a/src/bin/main.rs b/src/bin/main.rs deleted file mode 100644 index 22e0586..0000000 --- a/src/bin/main.rs +++ /dev/null @@ -1,140 +0,0 @@ -// Copyright (C) 2014 The 6502-rs Developers -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions -// are met: -// 1. Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// 3. Neither the names of the copyright holders nor the names of any -// contributors may be used to endorse or promote products derived from this -// software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. - -extern crate mos6502; - -#[cfg(not(test))] -use mos6502::cpu; - -#[cfg(not(test))] -use mos6502::address::Address; - -#[cfg(not(test))] -fn main() { - let mut cpu = cpu::CPU::new(); - - // "Load" a program - - // JAM: FIXME: What's the syntax for specifying the array element type, - // but not the length? (For a fixed-size array) - - let zero_page_data: [u8; 17] = [ - // ZeroPage data start - 0x00, - 0x02, // ADC ZeroPage target - 0x00, - 0x04, // ADC ZeroPageX target - 0x00, - 0x00, - 0x00, - 0x00, - 0x10, // ADC IndexedIndirectX address - 0x80, // ADC IndexedIndirectX address - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x08, // ADC IndirectIndexedY address - 0x80, // ADC IndirectIndexedY address - ]; - - let program: [u8; 33] = [ - // Code start - 0xA9, // LDA Immediate - 0x01, // Immediate operand - 0x69, // ADC Immediate - 0x07, // Immediate operand - 0x65, // ADC ZeroPage - 0x01, // ZeroPage operand - 0xA2, // LDX Immediate - 0x01, // Immediate operand - 0x75, // ADC ZeroPageX - 0x02, // ZeroPageX operand - 0x6D, // ADC Absolute - 0x01, // Absolute operand - 0x80, // Absolute operand - 0xA2, // LDX immediate - 0x08, // Immediate operand - 0x7D, // ADC AbsoluteX - 0x00, // AbsoluteX operand - 0x80, // AbsoluteX operand - 0xA0, // LDY immediate - 0x04, // Immediate operand - 0x79, // ADC AbsoluteY - 0x00, // AbsoluteY operand - 0x80, // AbsoluteY operand - 0xA2, // LDX immediate - 0x05, // Immediate operand - 0x61, // ADC IndexedIndirectX - 0x03, // IndexedIndirectX operand - 0xA0, // LDY immediate - 0x10, // Immediate operand - 0x71, // ADC IndirectIndexedY - 0x0F, // IndirectIndexedY operand - 0xEA, // NOP :) - 0xFF, // Something invalid -- the end! - ]; - - let data: [u8; 25] = [ - 0x00, - 0x09, // ADC Absolute target - 0x00, - 0x00, - 0x40, // ADC AbsoluteY target - 0x00, - 0x00, - 0x00, - 0x11, // ADC AbsoluteX target - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x12, // ADC IndexedIndirectX target - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x06, // ADC IndirectIndexedY target - ]; - - cpu.memory.set_bytes(Address(0x0000), &zero_page_data); - cpu.memory.set_bytes(Address(0x4000), &program); - cpu.memory.set_bytes(Address(0x8000), &data); - - cpu.registers.program_counter = Address(0x4000); - - cpu.run(); - - println!("{:?}", cpu); -} diff --git a/tests/skeptic.rs b/tests/skeptic.rs new file mode 100644 index 0000000..ff46c9c --- /dev/null +++ b/tests/skeptic.rs @@ -0,0 +1 @@ +include!(concat!(env!("OUT_DIR"), "/skeptic-tests.rs")); From ddfb3a3b29dcdb5b55743be19237a2a848ea1872 Mon Sep 17 00:00:00 2001 From: kzzt Date: Thu, 25 Oct 2018 13:29:38 -0500 Subject: [PATCH 4/8] ran clippy and renamed main.rs to mos6502.rs --- src/bin/{main.rs => mos6502.rs} | 0 src/cpu.rs | 9 +++------ src/registers.rs | 16 ++++++++-------- 3 files changed, 11 insertions(+), 14 deletions(-) rename src/bin/{main.rs => mos6502.rs} (100%) diff --git a/src/bin/main.rs b/src/bin/mos6502.rs similarity index 100% rename from src/bin/main.rs rename to src/bin/mos6502.rs diff --git a/src/cpu.rs b/src/cpu.rs index 2bdca43..bfdfc14 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -410,13 +410,10 @@ impl CPU { } pub fn run(&mut self) { - loop { - if let Some(decoded_instr) = self.fetch_next_and_decode() { + while let Some(decoded_instr) = self.fetch_next_and_decode() { self.execute_instruction(decoded_instr); - } else { - break; - } - } + } + } fn set_flags_from_i8(status: &mut Status, value: i8) { diff --git a/src/registers.rs b/src/registers.rs index 77ea196..cb3dc91 100644 --- a/src/registers.rs +++ b/src/registers.rs @@ -58,17 +58,17 @@ impl StatusArgs { bitflags! { pub struct Status: u8 { - const PS_NEGATIVE = 0b10000000; - const PS_OVERFLOW = 0b01000000; - const PS_UNUSED = 0b00100000; // JAM: Should this exist? + const PS_NEGATIVE = 0b1000_0000; + const PS_OVERFLOW = 0b0100_0000; + const PS_UNUSED = 0b0010_0000; // JAM: Should this exist? // (note that it affects the // behavior of things like // from_bits_truncate) - const PS_BRK = 0b00010000; - const PS_DECIMAL_MODE = 0b00001000; - const PS_DISABLE_INTERRUPTS = 0b00000100; - const PS_ZERO = 0b00000010; - const PS_CARRY = 0b00000001; + const PS_BRK = 0b0001_0000; + const PS_DECIMAL_MODE = 0b0000_1000; + const PS_DISABLE_INTERRUPTS = 0b0000_0100; + const PS_ZERO = 0b0000_0010; + const PS_CARRY = 0b0000_0001; } } From 7e8171487e2b222847dd138c0e8dfc1c8f53da65 Mon Sep 17 00:00:00 2001 From: Noppadet Vivatchotikul Date: Fri, 26 Oct 2018 09:50:43 +0700 Subject: [PATCH 5/8] fix syntax error --- src/cpu.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cpu.rs b/src/cpu.rs index c2e38e4..3e9191b 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -1160,7 +1160,7 @@ mod tests { #[cfg(test)] fn compare_test_helper(compare: &mut F, load_instruction: Instruction) where - F: FnMut(&mut cpu, u8), + F: FnMut(&mut CPU, u8), { let mut cpu = CPU::new(); @@ -1215,7 +1215,7 @@ mod tests { #[test] fn compare_with_a_register_test() { compare_test_helper( - &mut |CPU: &mut cpu, val: u8| { + &mut |cpu: &mut CPU, val: u8| { cpu.compare_with_a_register(val); }, Instruction::LDA, @@ -1225,7 +1225,7 @@ mod tests { #[test] fn compare_with_x_register_test() { compare_test_helper( - &mut |CPU: &mut cpu, val: u8| { + &mut |cpu: &mut CPU, val: u8| { cpu.compare_with_x_register(val); }, Instruction::LDX, @@ -1235,7 +1235,7 @@ mod tests { #[test] fn compare_with_y_register_test() { compare_test_helper( - &mut |CPU: &mut cpu, val: u8| { + &mut |cpu: &mut CPU, val: u8| { cpu.compare_with_y_register(val); }, Instruction::LDY, From d041a62aac868f17076e1204d9342b61c15abb05 Mon Sep 17 00:00:00 2001 From: Stefano Probst Date: Sat, 27 Oct 2018 11:05:07 +0200 Subject: [PATCH 6/8] Sync binary example with the bin folder --- src/bin/mos6502.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/bin/mos6502.rs b/src/bin/mos6502.rs index 22e0586..df56d6d 100644 --- a/src/bin/mos6502.rs +++ b/src/bin/mos6502.rs @@ -39,10 +39,7 @@ fn main() { // "Load" a program - // JAM: FIXME: What's the syntax for specifying the array element type, - // but not the length? (For a fixed-size array) - - let zero_page_data: [u8; 17] = [ + let zero_page_data = [ // ZeroPage data start 0x00, 0x02, // ADC ZeroPage target @@ -63,7 +60,7 @@ fn main() { 0x80, // ADC IndirectIndexedY address ]; - let program: [u8; 33] = [ + let program = [ // Code start 0xA9, // LDA Immediate 0x01, // Immediate operand @@ -100,7 +97,7 @@ fn main() { 0xFF, // Something invalid -- the end! ]; - let data: [u8; 25] = [ + let data = [ 0x00, 0x09, // ADC Absolute target 0x00, From 7df3f75934523c384240bee9fd690d5b71f47d34 Mon Sep 17 00:00:00 2001 From: Stefano Probst Date: Tue, 30 Oct 2018 12:32:36 +0100 Subject: [PATCH 7/8] More stable future for this project. Change some casts from `as` to a `TYPE::from(x)` style so that the compile can warn us in the future for some things. See also https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#cast_lossless --- src/address.rs | 3 +-- src/cpu.rs | 14 +++++++------- src/instruction.rs | 18 +++++++++--------- src/registers.rs | 2 +- 4 files changed, 18 insertions(+), 19 deletions(-) diff --git a/src/address.rs b/src/address.rs index 0479a96..47666c1 100644 --- a/src/address.rs +++ b/src/address.rs @@ -42,8 +42,7 @@ impl Add for Address { fn add(self, AddressDiff(rhs): AddressDiff) -> Address { let Address(lhs) = self; - // TODO akeeton: Do a checked cast. - Address(((lhs as i32) + rhs) as u16) + Address(((i32::from(lhs)) + rhs) as u16) } } diff --git a/src/cpu.rs b/src/cpu.rs index 91e6dc5..d925519 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -109,17 +109,17 @@ impl CPU { } (Instruction::BCC, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_carry_clear(addr); } (Instruction::BCS, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_carry_set(addr); } (Instruction::BEQ, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_equal(addr); } @@ -149,23 +149,23 @@ impl CPU { } (Instruction::BMI, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); debug!("branch if minus relative. address: {:?}", addr); self.branch_if_minus(addr); } (Instruction::BPL, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_positive(addr); } (Instruction::BVC, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_overflow_clear(addr); } (Instruction::BVS, OpInput::UseRelative(rel)) => { - let addr = self.registers.program_counter + AddressDiff(rel as i32); + let addr = self.registers.program_counter + AddressDiff(i32::from(rel)); self.branch_if_overflow_set(addr); } diff --git a/src/instruction.rs b/src/instruction.rs index cf77feb..ac053f2 100644 --- a/src/instruction.rs +++ b/src/instruction.rs @@ -139,7 +139,7 @@ pub enum AddressingMode { fn arr_to_addr(arr: &[u8]) -> Address { debug_assert!(arr.len() == 2); - let x = (arr[0] as u16) + ((arr[1] as u16) << 8usize); + let x = u16::from(arr[0]) + (u16::from(arr[1]) << 8usize); Address(x) } @@ -187,19 +187,19 @@ impl AddressingMode { // Use [u8, ..1] from instruction // Interpret as zero page address // (Output: an 8-bit zero-page address) - OpInput::UseAddress(Address(arr[0] as u16)) + OpInput::UseAddress(Address(u16::from(arr[0]))) } AddressingMode::ZeroPageX => { // Use [u8, ..1] from instruction // Add to X register (as u8 -- the final address is in 0-page) // (Output: an 8-bit zero-page address) - OpInput::UseAddress(Address((arr[0] + x) as u16)) + OpInput::UseAddress(Address(u16::from(arr[0] + x))) } AddressingMode::ZeroPageY => { // Use [u8, ..1] from instruction // Add to Y register (as u8 -- the final address is in 0-page) // (Output: an 8-bit zero-page address) - OpInput::UseAddress(Address((arr[0] + y) as u16)) + OpInput::UseAddress(Address(u16::from(arr[0] + y))) } AddressingMode::Relative => { // Use [u8, ..1] from instruction @@ -214,12 +214,12 @@ impl AddressingMode { AddressingMode::AbsoluteX => { // Use [u8, ..2] from instruction as address, add X // (Output: a 16-bit address) - OpInput::UseAddress(arr_to_addr(arr) + AddressDiff(x as i32)) + OpInput::UseAddress(arr_to_addr(arr) + AddressDiff(i32::from(x))) } AddressingMode::AbsoluteY => { // Use [u8, ..2] from instruction as address, add Y // (Output: a 16-bit address) - OpInput::UseAddress(arr_to_addr(arr) + AddressDiff(y as i32)) + OpInput::UseAddress(arr_to_addr(arr) + AddressDiff(i32::from(y))) } AddressingMode::Indirect => { // Use [u8, ..2] from instruction as an address. Interpret the @@ -234,7 +234,7 @@ impl AddressingMode { // This is where the absolute (16-bit) target address is stored. // (Output: a 16-bit address) let start = arr[0] + x; - let slice = memory.get_slice(Address(start as u16), AddressDiff(2)); + let slice = memory.get_slice(Address(u16::from(start)), AddressDiff(2)); OpInput::UseAddress(arr_to_addr(slice)) } AddressingMode::IndirectIndexedY => { @@ -243,8 +243,8 @@ impl AddressingMode { // Add Y register to this address to get the final address // (Output: a 16-bit address) let start = arr[0]; - let slice = memory.get_slice(Address(start as u16), AddressDiff(2)); - OpInput::UseAddress(arr_to_addr(slice) + AddressDiff(y as i32)) + let slice = memory.get_slice(Address(u16::from(start)), AddressDiff(2)); + OpInput::UseAddress(arr_to_addr(slice) + AddressDiff(i32::from(y))) } } } diff --git a/src/registers.rs b/src/registers.rs index cb3dc91..50108bb 100644 --- a/src/registers.rs +++ b/src/registers.rs @@ -146,7 +146,7 @@ pub struct StackPointer(pub u8); impl StackPointer { pub fn to_address(&self) -> Address { let StackPointer(sp) = *self; - STACK_ADDRESS_LO + AddressDiff(sp as i32) + STACK_ADDRESS_LO + AddressDiff(i32::from(sp)) } // JAM: FIXME: Should we prevent overflow here? What would a 6502 do? From 8239b298cbaf44e9f1120d0f9a9ea8bed105ea1e Mon Sep 17 00:00:00 2001 From: Stefano Probst Date: Tue, 30 Oct 2018 12:40:41 +0100 Subject: [PATCH 8/8] Simplify some expressions by using the assign op pattern. See also https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#assign_op_pattern --- src/cpu.rs | 2 +- src/registers.rs | 20 ++++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/cpu.rs b/src/cpu.rs index d925519..4028e2b 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -448,7 +448,7 @@ impl CPU { fn shift_right_with_flags(p_val: &mut u8, status: &mut Status) { let mask = 1; let is_bit_0_set = (*p_val & mask) == mask; - *p_val = *p_val >> 1; + *p_val >>= 1; status.set_with_mask( PS_CARRY, Status::new(StatusArgs { diff --git a/src/registers.rs b/src/registers.rs index 50108bb..485e923 100644 --- a/src/registers.rs +++ b/src/registers.rs @@ -100,39 +100,39 @@ impl Status { let mut out = Status::empty(); if negative { - out = out | PS_NEGATIVE + out |= PS_NEGATIVE } if overflow { - out = out | PS_OVERFLOW + out |= PS_OVERFLOW } if unused { - out = out | PS_UNUSED + out |= PS_UNUSED } if brk { - out = out | PS_BRK + out |= PS_BRK } if decimal_mode { - out = out | PS_DECIMAL_MODE + out |= PS_DECIMAL_MODE } if disable_interrupts { - out = out | PS_DISABLE_INTERRUPTS + out |= PS_DISABLE_INTERRUPTS } if zero { - out = out | PS_ZERO + out |= PS_ZERO } if carry { - out = out | PS_CARRY + out |= PS_CARRY } out } pub fn and(&mut self, rhs: Status) { - *self = *self & rhs; + *self &= rhs; } pub fn or(&mut self, rhs: Status) { - *self = *self | rhs; + *self |= rhs; } pub fn set_with_mask(&mut self, mask: Status, rhs: Status) {