gb-emu/src/util.rs

use crate::processor::Direction;
use std::mem::transmute;

pub(crate) fn as_signed(unsigned: u8) -> i8 {
    unsafe { transmute(unsigned) }
}

pub(crate) fn get_bit(byte: u8, flag: u8) -> bool {
    let mask = 1 << flag;
    let got = byte & mask;
    got > 0x0
}

pub(crate) fn set_or_clear_bit(byte: u8, flag: u8, condition: bool) -> u8 {
    if condition {
        set_bit(byte, flag)
    } else {
        clear_bit(byte, flag)
    }
}

pub(crate) fn set_bit(byte: u8, flag: u8) -> u8 {
    byte | (1 << flag)
}

pub(crate) fn clear_bit(byte: u8, flag: u8) -> u8 {
    byte & (!(1 << flag))
}

pub(crate) fn rotate(byte: u8, direction: &Direction) -> (u8, bool) {
    match direction {
        Direction::Left => {
            let carry = get_bit(byte, 7);
            let r = byte << 1;
            (r, carry)
        }
        Direction::Right => {
            let carry = get_bit(byte, 0);
            let r = byte >> 1;
            (r, carry)
        }
    }
}

pub(crate) fn get_rotation_carry(direction: &Direction) -> u8 {
    match direction {
        Direction::Left => 0b1,
        Direction::Right => 0b10000000,
    }
}

pub trait Nibbles {
    fn get_low_nibble(&self) -> u8;
    fn get_high_nibble(&self) -> u8;
    fn set_low_nibble(&mut self, val: u8);
    fn set_high_nibble(&mut self, val: u8);
}

impl Nibbles for u8 {
    fn get_low_nibble(&self) -> u8 {
        *self & 0x0F
    }

    fn get_high_nibble(&self) -> u8 {
        (*self >> 4) & 0x0F
    }

    fn set_low_nibble(&mut self, val: u8) {
        *self = (*self & 0xF0) | (val & 0x0F);
    }

    fn set_high_nibble(&mut self, val: u8) {
        *self = (*self & 0x0F) | (val << 4);
    }
}