alex/gb-emu
1
0
Fork 0
Code Pull requests Releases Packages Activity Actions

give flags their Full Name

Browse source
This commit is contained in:
Alex Janka 2023-01-22 13:09:31 +11:00
parent 13bd9f0a1c
commit 17f037fb27
2 changed files with 79 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
src/processor/mod.rs
View file

@ -10,10 +10,10 @@ mod opcodes;
#[allow(dead_code)] #[allow(dead_code)]
#[derive(PartialEq)] #[derive(PartialEq)]
enum FLAGS { enum FLAGS {
Z = 7, Zero = 7,
N = 6, NSubtract = 6,
H = 5, HalfCarry = 5,
C = 4, Carry = 4,
} }
enum Direction { enum Direction {
@ -69,19 +69,19 @@ impl CPU {
let (mut rotated, carry) = rotate(byte, &direction); let (mut rotated, carry) = rotate(byte, &direction);
if carry { if carry {
rotated += get_rotation_carry(&direction); rotated += get_rotation_carry(&direction);
self.set_flag(FLAGS::C); self.set_flag(FLAGS::Carry);
} }
return rotated; return rotated;
} }
fn rotate(&mut self, byte: u8, direction: Direction) -> u8 { fn rotate(&mut self, byte: u8, direction: Direction) -> u8 {
let old_carry = self.get_flag(FLAGS::C); let old_carry = self.get_flag(FLAGS::Carry);
let (mut rotated, carry) = rotate(byte, &direction); let (mut rotated, carry) = rotate(byte, &direction);
if old_carry > 0 { if old_carry > 0 {
rotated += get_rotation_carry(&direction); rotated += get_rotation_carry(&direction);
} }
if carry { if carry {
self.set_flag(FLAGS::C); self.set_flag(FLAGS::Carry);
} }
return rotated; return rotated;
} }
@ -107,13 +107,13 @@ impl CPU {
fn shift(&mut self, byte: u8, direction: Direction) -> u8 { fn shift(&mut self, byte: u8, direction: Direction) -> u8 {
let (rotated, carry) = rotate(byte, &direction); let (rotated, carry) = rotate(byte, &direction);
if carry { if carry {
self.set_flag(FLAGS::C); self.set_flag(FLAGS::Carry);
} }
return rotated; return rotated;
} }
fn bit(&mut self, byte: u8, bit: u8) { fn bit(&mut self, byte: u8, bit: u8) {
self.set_or_clear_flag(FLAGS::Z, !get_bit(byte, bit)); self.set_or_clear_flag(FLAGS::Zero, !get_bit(byte, bit));
} }
fn rst(&mut self, address: u16) { fn rst(&mut self, address: u16) {
@ -177,7 +177,7 @@ impl CPU {
} }
fn set_flag(&mut self, flag: FLAGS) { fn set_flag(&mut self, flag: FLAGS) {
if flag == FLAGS::Z { if flag == FLAGS::Zero {
verbose_println!("setting z flag"); verbose_println!("setting z flag");
} }
unsafe { unsafe {
@ -215,11 +215,11 @@ impl CPU {
fn add_u8s(&mut self, first: u8, second: u8) -> u8 { fn add_u8s(&mut self, first: u8, second: u8) -> u8 {
let (result, carry) = first.overflowing_add(second); let (result, carry) = first.overflowing_add(second);
self.clear_flag(FLAGS::N); self.clear_flag(FLAGS::NSubtract);
self.set_or_clear_flag(FLAGS::C, carry); self.set_or_clear_flag(FLAGS::Carry, carry);
self.set_or_clear_flag(FLAGS::Z, result == 0x0); self.set_or_clear_flag(FLAGS::Zero, result == 0x0);
self.set_or_clear_flag( self.set_or_clear_flag(
FLAGS::H, FLAGS::HalfCarry,
(((first & 0xF).wrapping_add(second & 0xF)) & 0x10) == 0x10, (((first & 0xF).wrapping_add(second & 0xF)) & 0x10) == 0x10,
); );
return result; return result;
@ -227,11 +227,11 @@ impl CPU {
fn add_u16s(&mut self, first: u16, second: u16) -> u16 { fn add_u16s(&mut self, first: u16, second: u16) -> u16 {
let (result, carry) = first.overflowing_add(second); let (result, carry) = first.overflowing_add(second);
self.clear_flag(FLAGS::N); self.clear_flag(FLAGS::NSubtract);
self.set_or_clear_flag(FLAGS::C, carry); self.set_or_clear_flag(FLAGS::Carry, carry);
self.set_or_clear_flag(FLAGS::Z, result == 0x0); self.set_or_clear_flag(FLAGS::Zero, result == 0x0);
self.set_or_clear_flag( self.set_or_clear_flag(
FLAGS::H, FLAGS::HalfCarry,
(((first & 0xFFF).wrapping_add(second & 0xFFF)) & 0x1000) == 0x1000, (((first & 0xFFF).wrapping_add(second & 0xFFF)) & 0x1000) == 0x1000,
); );
return result; return result;
@ -239,11 +239,11 @@ impl CPU {
fn sub_u8s(&mut self, first: u8, second: u8) -> u8 { fn sub_u8s(&mut self, first: u8, second: u8) -> u8 {
let (result, carry) = first.overflowing_sub(second); let (result, carry) = first.overflowing_sub(second);
self.set_flag(FLAGS::N); self.set_flag(FLAGS::NSubtract);
self.set_or_clear_flag(FLAGS::C, carry); self.set_or_clear_flag(FLAGS::Carry, carry);
self.set_or_clear_flag(FLAGS::Z, result == 0x0); self.set_or_clear_flag(FLAGS::Zero, result == 0x0);
self.set_or_clear_flag( self.set_or_clear_flag(
FLAGS::H, FLAGS::HalfCarry,
(((first & 0xF).wrapping_sub(second & 0xF)) & 0x10) == 0x10, (((first & 0xF).wrapping_sub(second & 0xF)) & 0x10) == 0x10,
); );
return result; return result;
@ -251,11 +251,11 @@ impl CPU {
fn sub_u16s(&mut self, first: u16, second: u16) -> u16 { fn sub_u16s(&mut self, first: u16, second: u16) -> u16 {
let (result, carry) = first.overflowing_sub(second); let (result, carry) = first.overflowing_sub(second);
self.set_flag(FLAGS::N); self.set_flag(FLAGS::NSubtract);
self.set_or_clear_flag(FLAGS::C, carry); self.set_or_clear_flag(FLAGS::Carry, carry);
self.set_or_clear_flag(FLAGS::Z, result == 0x0); self.set_or_clear_flag(FLAGS::Zero, result == 0x0);
self.set_or_clear_flag( self.set_or_clear_flag(
FLAGS::H, FLAGS::HalfCarry,
(((first & 0xFFF).wrapping_sub(second & 0xFFF)) & 0x1000) == 0x1000, (((first & 0xFFF).wrapping_sub(second & 0xFFF)) & 0x1000) == 0x1000,
); );
return result; return result;

104
src/processor/opcodes.rs
View file

@ -83,7 +83,7 @@ impl CPU {
}, },
0x20 => { 0x20 => {
let jump_size = self.ld_immediate_byte(); let jump_size = self.ld_immediate_byte();
if self.get_flag(FLAGS::Z) == 0 { if self.get_flag(FLAGS::Zero) == 0 {
verbose_println!("z flag is 0... so doing jump..."); verbose_println!("z flag is 0... so doing jump...");
unsafe { unsafe {
self.state.pc.as_u16 = self self.state.pc.as_u16 = self
@ -96,7 +96,7 @@ impl CPU {
unsafe { unsafe {
verbose_println!( verbose_println!(
"not jumping! z flag is {0:#b}, flags are {1:#b} / {1:#X}", "not jumping! z flag is {0:#b}, flags are {1:#b} / {1:#X}",
self.get_flag(FLAGS::Z), self.get_flag(FLAGS::Zero),
self.state.af.as_u8s.right self.state.af.as_u8s.right
); );
} }
@ -118,18 +118,20 @@ impl CPU {
0x26 => self.state.hl.as_u8s.left = self.ld_immediate_byte(), 0x26 => self.state.hl.as_u8s.left = self.ld_immediate_byte(),
0x27 => unsafe { 0x27 => unsafe {
verbose_println!("Running DAA instruction (0x27) that I'm not too sure about..."); verbose_println!("Running DAA instruction (0x27) that I'm not too sure about...");
if self.get_flag(FLAGS::N) == 0 { if self.get_flag(FLAGS::NSubtract) == 0 {
if self.get_flag(FLAGS::C) == 1 || self.state.af.as_u8s.left > 0x99 { if self.get_flag(FLAGS::Carry) == 1 || self.state.af.as_u8s.left > 0x99 {
self.state.af.as_u8s.left += 0x60; self.state.af.as_u8s.left += 0x60;
} }
if self.get_flag(FLAGS::H) == 1 || (self.state.af.as_u8s.left & 0x0f) > 0x09 { if self.get_flag(FLAGS::HalfCarry) == 1
|| (self.state.af.as_u8s.left & 0x0f) > 0x09
{
self.state.af.as_u8s.left += 0x6; self.state.af.as_u8s.left += 0x6;
} }
} else { } else {
if self.get_flag(FLAGS::C) == 1 { if self.get_flag(FLAGS::Carry) == 1 {
self.state.af.as_u8s.left -= 0x60; self.state.af.as_u8s.left -= 0x60;
} }
if self.get_flag(FLAGS::H) == 1 { if self.get_flag(FLAGS::HalfCarry) == 1 {
self.state.af.as_u8s.left -= 0x6; self.state.af.as_u8s.left -= 0x6;
} }
} }
@ -140,7 +142,7 @@ impl CPU {
}, },
0x28 => { 0x28 => {
let jump_size = self.ld_immediate_byte(); let jump_size = self.ld_immediate_byte();
if self.get_flag(FLAGS::Z) == 1 { if self.get_flag(FLAGS::Zero) == 1 {
unsafe { unsafe {
self.state.pc.as_u16 = self self.state.pc.as_u16 = self
.state .state
@ -168,7 +170,7 @@ impl CPU {
0x2F => unsafe { self.state.af.as_u8s.left = !self.state.af.as_u8s.left }, 0x2F => unsafe { self.state.af.as_u8s.left = !self.state.af.as_u8s.left },
0x30 => { 0x30 => {
let jump_size = self.ld_immediate_byte(); let jump_size = self.ld_immediate_byte();
if self.get_flag(FLAGS::C) == 0 { if self.get_flag(FLAGS::Carry) == 0 {
unsafe { unsafe {
self.state.pc.as_u16 = self self.state.pc.as_u16 = self
.state .state
@ -199,10 +201,10 @@ impl CPU {
let data = self.ld_immediate_byte(); let data = self.ld_immediate_byte();
self.memory.set(self.state.hl.as_u16, data); self.memory.set(self.state.hl.as_u16, data);
}, },
0x37 => self.set_flag(FLAGS::C), 0x37 => self.set_flag(FLAGS::Carry),
0x38 => { 0x38 => {
let jump_size = self.ld_immediate_byte(); let jump_size = self.ld_immediate_byte();
if self.get_flag(FLAGS::C) == 1 { if self.get_flag(FLAGS::Carry) == 1 {
unsafe { unsafe {
self.state.pc.as_u16 = self self.state.pc.as_u16 = self
.state .state
@ -227,7 +229,7 @@ impl CPU {
self.state.af.as_u8s.left = self.sub_u8s(self.state.af.as_u8s.left, 1) self.state.af.as_u8s.left = self.sub_u8s(self.state.af.as_u8s.left, 1)
}, },
0x3E => self.state.af.as_u8s.left = self.ld_immediate_byte(), 0x3E => self.state.af.as_u8s.left = self.ld_immediate_byte(),
0x3F => self.toggle_flag(FLAGS::C), 0x3F => self.toggle_flag(FLAGS::Carry),
0x40 => {} 0x40 => {}
0x41 => unsafe { self.state.bc.as_u8s.left = self.state.bc.as_u8s.right }, 0x41 => unsafe { self.state.bc.as_u8s.left = self.state.bc.as_u8s.right },
0x42 => unsafe { self.state.bc.as_u8s.left = self.state.de.as_u8s.left }, 0x42 => unsafe { self.state.bc.as_u8s.left = self.state.de.as_u8s.left },
@ -348,46 +350,46 @@ impl CPU {
self.add_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left) self.add_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left)
}, },
0x88 => unsafe { 0x88 => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.left + f) self.add_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.left + f)
}, },
0x89 => unsafe { 0x89 => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.add_u8s( self.state.af.as_u8s.left = self.add_u8s(
self.state.af.as_u8s.left, self.state.af.as_u8s.left,
self.state.bc.as_u8s.right.wrapping_add(f), self.state.bc.as_u8s.right.wrapping_add(f),
) )
}, },
0x8A => unsafe { 0x8A => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.left + f) self.add_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.left + f)
}, },
0x8B => unsafe { 0x8B => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.right + f) self.add_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.right + f)
}, },
0x8C => unsafe { 0x8C => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.left + f) self.add_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.left + f)
}, },
0x8D => unsafe { 0x8D => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.right + f) self.add_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.right + f)
}, },
0x8E => unsafe { 0x8E => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.add_u8s( self.state.af.as_u8s.left = self.add_u8s(
self.state.af.as_u8s.left, self.state.af.as_u8s.left,
self.memory.get(self.state.hl.as_u16).wrapping_add(f), self.memory.get(self.state.hl.as_u16).wrapping_add(f),
) )
}, },
0x8F => unsafe { 0x8F => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.add_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left + f) self.add_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left + f)
}, },
@ -426,44 +428,44 @@ impl CPU {
self.sub_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left) self.sub_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left)
}, },
0x98 => unsafe { 0x98 => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.left + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.left + f)
}, },
0x99 => unsafe { 0x99 => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.right + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.bc.as_u8s.right + f)
}, },
0x9A => unsafe { 0x9A => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.left + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.left + f)
}, },
0x9B => unsafe { 0x9B => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.right + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.de.as_u8s.right + f)
}, },
0x9C => unsafe { 0x9C => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.left + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.left + f)
}, },
0x9D => unsafe { 0x9D => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.right + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.hl.as_u8s.right + f)
}, },
0x9E => unsafe { 0x9E => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.sub_u8s( self.state.af.as_u8s.left = self.sub_u8s(
self.state.af.as_u8s.left, self.state.af.as_u8s.left,
self.memory.get(self.state.hl.as_u16) + f, self.memory.get(self.state.hl.as_u16) + f,
) )
}, },
0x9F => unsafe { 0x9F => unsafe {
let f = self.get_flag(FLAGS::C); let f = self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.state.af.as_u8s.left =
self.sub_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left + f) self.sub_u8s(self.state.af.as_u8s.left, self.state.af.as_u8s.left + f)
}, },
@ -577,42 +579,42 @@ impl CPU {
}, },
0xB8 => unsafe { 0xB8 => unsafe {
if self.state.af.as_u8s.left == self.state.bc.as_u8s.left { if self.state.af.as_u8s.left == self.state.bc.as_u8s.left {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xB9 => unsafe { 0xB9 => unsafe {
if self.state.af.as_u8s.left == self.state.bc.as_u8s.right { if self.state.af.as_u8s.left == self.state.bc.as_u8s.right {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBA => unsafe { 0xBA => unsafe {
if self.state.af.as_u8s.left == self.state.de.as_u8s.left { if self.state.af.as_u8s.left == self.state.de.as_u8s.left {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBB => unsafe { 0xBB => unsafe {
if self.state.af.as_u8s.left == self.state.de.as_u8s.right { if self.state.af.as_u8s.left == self.state.de.as_u8s.right {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBC => unsafe { 0xBC => unsafe {
if self.state.af.as_u8s.left == self.state.hl.as_u8s.left { if self.state.af.as_u8s.left == self.state.hl.as_u8s.left {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBD => unsafe { 0xBD => unsafe {
if self.state.af.as_u8s.left == self.state.hl.as_u8s.right { if self.state.af.as_u8s.left == self.state.hl.as_u8s.right {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBE => unsafe { 0xBE => unsafe {
if self.state.af.as_u8s.left == self.memory.get(self.state.hl.as_u16) { if self.state.af.as_u8s.left == self.memory.get(self.state.hl.as_u16) {
self.set_flag(FLAGS::Z); self.set_flag(FLAGS::Zero);
} }
}, },
0xBF => self.set_flag(FLAGS::Z), 0xBF => self.set_flag(FLAGS::Zero),
0xC0 => unsafe { 0xC0 => unsafe {
if self.get_flag(FLAGS::Z) == 0 { if self.get_flag(FLAGS::Zero) == 0 {
let address = self.state.sp.as_u16; let address = self.state.sp.as_u16;
self.state.pc.as_u8s.left = self.memory.get(address); self.state.pc.as_u8s.left = self.memory.get(address);
self.state.pc.as_u8s.right = self.memory.get(address + 1); self.state.pc.as_u8s.right = self.memory.get(address + 1);
@ -627,7 +629,7 @@ impl CPU {
}, },
0xC2 => { 0xC2 => {
let word = self.ld_immediate_word(); let word = self.ld_immediate_word();
if self.get_flag(FLAGS::Z) == 0 { if self.get_flag(FLAGS::Zero) == 0 {
self.state.pc = word; self.state.pc = word;
} }
} }
@ -636,7 +638,7 @@ impl CPU {
} }
0xC4 => { 0xC4 => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::Z) == 0 { if self.get_flag(FLAGS::Zero) == 0 {
self.push(self.state.pc); self.push(self.state.pc);
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
@ -648,14 +650,14 @@ impl CPU {
}, },
0xC7 => self.rst(0x00), 0xC7 => self.rst(0x00),
0xC8 => { 0xC8 => {
if self.get_flag(FLAGS::Z) == 1 { if self.get_flag(FLAGS::Zero) == 1 {
self.state.pc = self.pop_word() self.state.pc = self.pop_word()
} }
} }
0xC9 => self.state.pc = self.pop_word(), 0xC9 => self.state.pc = self.pop_word(),
0xCA => { 0xCA => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::Z) == 1 { if self.get_flag(FLAGS::Zero) == 1 {
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
} }
@ -665,7 +667,7 @@ impl CPU {
} }
0xCC => { 0xCC => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::Z) == 1 { if self.get_flag(FLAGS::Zero) == 1 {
self.push(self.state.pc); self.push(self.state.pc);
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
@ -675,12 +677,12 @@ impl CPU {
self.state.pc = self.ld_immediate_word(); self.state.pc = self.ld_immediate_word();
} }
0xCE => unsafe { 0xCE => unsafe {
let t = self.ld_immediate_byte() + self.get_flag(FLAGS::C); let t = self.ld_immediate_byte() + self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.add_u8s(self.state.af.as_u8s.left, t) self.state.af.as_u8s.left = self.add_u8s(self.state.af.as_u8s.left, t)
}, },
0xCF => self.rst(0x08), 0xCF => self.rst(0x08),
0xD0 => unsafe { 0xD0 => unsafe {
if self.get_flag(FLAGS::C) == 0 { if self.get_flag(FLAGS::Carry) == 0 {
let address = self.state.sp.as_u16; let address = self.state.sp.as_u16;
self.state.pc.as_u8s.left = self.memory.get(address); self.state.pc.as_u8s.left = self.memory.get(address);
self.state.pc.as_u8s.right = self.memory.get(address + 1); self.state.pc.as_u8s.right = self.memory.get(address + 1);
@ -695,14 +697,14 @@ impl CPU {
}, },
0xD2 => { 0xD2 => {
let word = self.ld_immediate_word(); let word = self.ld_immediate_word();
if self.get_flag(FLAGS::C) == 0 { if self.get_flag(FLAGS::Carry) == 0 {
self.state.pc = word; self.state.pc = word;
} }
} }
0xD3 => undefined(0xD3), 0xD3 => undefined(0xD3),
0xD4 => { 0xD4 => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::C) == 0 { if self.get_flag(FLAGS::Carry) == 0 {
self.push(self.state.pc); self.push(self.state.pc);
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
@ -714,7 +716,7 @@ impl CPU {
}, },
0xD7 => self.rst(0x10), 0xD7 => self.rst(0x10),
0xD8 => { 0xD8 => {
if self.get_flag(FLAGS::C) == 1 { if self.get_flag(FLAGS::Carry) == 1 {
self.state.pc = self.pop_word() self.state.pc = self.pop_word()
} }
} }
@ -724,21 +726,21 @@ impl CPU {
} }
0xDA => { 0xDA => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::C) == 1 { if self.get_flag(FLAGS::Carry) == 1 {
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
} }
0xDB => undefined(0xDB), 0xDB => undefined(0xDB),
0xDC => { 0xDC => {
let maybe_next = self.ld_immediate_word(); let maybe_next = self.ld_immediate_word();
if self.get_flag(FLAGS::C) == 1 { if self.get_flag(FLAGS::Carry) == 1 {
self.push(self.state.pc); self.push(self.state.pc);
self.state.pc = maybe_next; self.state.pc = maybe_next;
} }
} }
0xDD => undefined(0xDE), 0xDD => undefined(0xDE),
0xDE => unsafe { 0xDE => unsafe {
let t = self.ld_immediate_byte() + self.get_flag(FLAGS::C); let t = self.ld_immediate_byte() + self.get_flag(FLAGS::Carry);
self.state.af.as_u8s.left = self.sub_u8s(self.state.af.as_u8s.left, t) self.state.af.as_u8s.left = self.sub_u8s(self.state.af.as_u8s.left, t)
}, },
0xDF => self.rst(0x18), 0xDF => self.rst(0x18),
@ -845,7 +847,7 @@ impl CPU {
0xFD => undefined(0xFD), 0xFD => undefined(0xFD),
0xFE => unsafe { 0xFE => unsafe {
if self.ld_immediate_byte() == self.state.af.as_u8s.left { if self.ld_immediate_byte() == self.state.af.as_u8s.left {
self.set_flag(FLAGS::Z) self.set_flag(FLAGS::Zero)
} }
}, },
0xFF => self.rst(0x38), 0xFF => self.rst(0x38),