Functions and tests for some bitwise operations and getter/setter for flag register

This commit is contained in:
Franco Colmenarez 2021-10-11 12:58:09 -05:00
parent b3e6baaa3f
commit d37699f4a8
4 changed files with 140 additions and 9 deletions

View File

@ -1,3 +1,4 @@
fn main() { fn main() {
println!("Hello, world!"); println!("TEST");
println!("{}", false as u8);
} }

View File

@ -1,3 +1,5 @@
use crate::utils::{BitIndex, get_bit, set_bit};
pub enum Register { pub enum Register {
A(u8), // Accumulator A(u8), // Accumulator
F(u8), // Flags F(u8), // Flags
@ -16,6 +18,13 @@ pub enum Register {
PC(u16), PC(u16),
} }
pub enum FlagRegister {
Zero(bool), // Set when the result of a math operation is zero or if two values matches using the CP instruction
Substract(bool), // Set if a substraction was performed in the last math instruction
HalfCarry(bool), // Set if a carry ocurred from the lower nibble in the last math operation
Carry(bool), // Set if a carry was ocurrend from the last math operation or if register A is the smaller value when executing the CP instruction
}
pub struct Registers { pub struct Registers {
a: u8, a: u8,
f: u8, f: u8,
@ -30,6 +39,21 @@ pub struct Registers {
} }
impl Registers { impl Registers {
pub fn new() -> Self {
Self {
a: 0,
f: 0b11110000, // The first 4 lower bits are always set to 0
b: 0,
c: 0,
d: 0,
e: 0,
h: 0,
l: 0,
sp: 0,
pc: 0,
}
}
pub fn get(&self, register: Register) -> u16 { pub fn get(&self, register: Register) -> u16 {
match register { match register {
Register::A(_) => self.a as u16, Register::A(_) => self.a as u16,
@ -50,14 +74,14 @@ impl Registers {
pub fn set(&mut self, register: Register) { pub fn set(&mut self, register: Register) {
match register { match register {
Register::A(val) => self.a = val, Register::A(val) => self.a = val,
Register::B(val) => self.b = val, Register::B(val) => self.b = val,
Register::C(val) => self.c = val, Register::C(val) => self.c = val,
Register::D(val) => self.d = val, Register::D(val) => self.d = val,
Register::E(val) => self.e = val, Register::E(val) => self.e = val,
Register::F(val) => self.f = val, Register::F(val) => self.f = val,
Register::H(val) => self.h = val, Register::H(val) => self.h = val,
Register::L(val) => self.l = val, Register::L(val) => self.l = val,
Register::BC(val) => self.set_bc(val), Register::BC(val) => self.set_bc(val),
Register::DE(val) => self.set_de(val), Register::DE(val) => self.set_de(val),
Register::HL(val) => self.set_hl(val), Register::HL(val) => self.set_hl(val),
@ -66,6 +90,24 @@ impl Registers {
} }
} }
pub fn get_flag(&self, flag: FlagRegister) -> bool {
match flag {
FlagRegister::Zero(_) => get_bit(self.f, BitIndex::I7),
FlagRegister::Substract(_) => get_bit(self.f, BitIndex::I6),
FlagRegister::HalfCarry(_) => get_bit(self.f, BitIndex::I5),
FlagRegister::Carry(_) => get_bit(self.f, BitIndex::I4),
}
}
pub fn set_flag(&mut self, flag: FlagRegister) {
match flag {
FlagRegister::Zero(val) => self.f = set_bit(self.f, val, BitIndex::I7),
FlagRegister::Substract(val) => self.f = set_bit(self.f, val, BitIndex::I6),
FlagRegister::HalfCarry(val) => self.f = set_bit(self.f, val, BitIndex::I5),
FlagRegister::Carry(val) => self.f = set_bit(self.f, val, BitIndex::I4),
}
}
fn get_bc(&self) -> u16 { fn get_bc(&self) -> u16 {
((self.b as u16) << 8) | (self.c as u16) ((self.b as u16) << 8) | (self.c as u16)
} }

View File

@ -1 +1,2 @@
pub mod utils;
pub mod cpu; pub mod cpu;

87
src/utils.rs Normal file
View File

@ -0,0 +1,87 @@
pub enum BitIndex {
I0,
I1,
I2,
I3,
I4,
I5,
I6,
I7,
}
pub fn get_bit_index(index: BitIndex) -> u8 {
match index {
BitIndex::I0 => 0,
BitIndex::I1 => 1,
BitIndex::I2 => 2,
BitIndex::I3 => 3,
BitIndex::I4 => 4,
BitIndex::I5 => 5,
BitIndex::I6 => 6,
BitIndex::I7 => 7,
}
}
pub fn get_bit(byte: u8, index: BitIndex) -> bool {
((byte >> get_bit_index(index)) & 0b00000001) == 1
}
pub fn set_bit(byte: u8, value: bool, index: BitIndex) -> u8 {
match value {
true => 0b00000001 << get_bit_index(index) | byte,
false => ((0b0000001 << get_bit_index(index)) ^ 0b11111111) & byte,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_set_bit() {
assert_eq!(set_bit(0b00000000, true, BitIndex::I0), 0b00000001);
assert_eq!(set_bit(0b00000000, true, BitIndex::I1), 0b00000010);
assert_eq!(set_bit(0b00000000, true, BitIndex::I2), 0b00000100);
assert_eq!(set_bit(0b00000000, true, BitIndex::I3), 0b00001000);
assert_eq!(set_bit(0b00000000, true, BitIndex::I4), 0b00010000);
assert_eq!(set_bit(0b00000000, true, BitIndex::I5), 0b00100000);
assert_eq!(set_bit(0b00000000, true, BitIndex::I6), 0b01000000);
assert_eq!(set_bit(0b00000000, true, BitIndex::I7), 0b10000000);
assert_eq!(set_bit(0b11111111, false, BitIndex::I0), 0b11111110);
assert_eq!(set_bit(0b11111111, false, BitIndex::I1), 0b11111101);
assert_eq!(set_bit(0b11111111, false, BitIndex::I2), 0b11111011);
assert_eq!(set_bit(0b11111111, false, BitIndex::I3), 0b11110111);
assert_eq!(set_bit(0b11111111, false, BitIndex::I4), 0b11101111);
assert_eq!(set_bit(0b11111111, false, BitIndex::I5), 0b11011111);
assert_eq!(set_bit(0b11111111, false, BitIndex::I6), 0b10111111);
assert_eq!(set_bit(0b11111111, false, BitIndex::I7), 0b01111111);
// Just a couple of random test
assert_eq!(set_bit(0b00000001, true, BitIndex::I0), 0b00000001);
assert_eq!(set_bit(0b11101111, true, BitIndex::I4), 0b11111111);
assert_eq!(set_bit(0b11111110, false, BitIndex::I0), 0b11111110);
assert_eq!(set_bit(0b00010000, false, BitIndex::I4), 0b00000000);
}
#[test]
fn test_get_bit() {
assert_eq!(get_bit(0b00000001, BitIndex::I0), true);
assert_eq!(get_bit(0b00000010, BitIndex::I1), true);
assert_eq!(get_bit(0b00000100, BitIndex::I2), true);
assert_eq!(get_bit(0b00001000, BitIndex::I3), true);
assert_eq!(get_bit(0b00010000, BitIndex::I4), true);
assert_eq!(get_bit(0b00100000, BitIndex::I5), true);
assert_eq!(get_bit(0b01000000, BitIndex::I6), true);
assert_eq!(get_bit(0b10000000, BitIndex::I7), true);
assert_eq!(get_bit(0b11111110, BitIndex::I0), false);
assert_eq!(get_bit(0b11111101, BitIndex::I1), false);
assert_eq!(get_bit(0b11111011, BitIndex::I2), false);
assert_eq!(get_bit(0b11110111, BitIndex::I3), false);
assert_eq!(get_bit(0b11101111, BitIndex::I4), false);
assert_eq!(get_bit(0b11011111, BitIndex::I5), false);
assert_eq!(get_bit(0b10111111, BitIndex::I6), false);
assert_eq!(get_bit(0b01111111, BitIndex::I7), false);
}
}