134 lines
4.5 KiB
Rust
134 lines
4.5 KiB
Rust
use crate::mapper::MemoryMapper;
|
|
use crate::structs::{get_register_pair, set_register, set_register_pair};
|
|
use crate::{get_register, EmulatorState, Register};
|
|
|
|
/// Sets the condition code flags according to `result`.
|
|
/// Does not set the carry flag and will always set the Z, S and P flags.
|
|
#[inline(always)]
|
|
fn set_cc<M: MemoryMapper>(state: &mut EmulatorState<M>, result: u8) {
|
|
state.cc.z = result == 0;
|
|
state.cc.s = result & 0x80 > 0;
|
|
state.cc.p = result.count_ones() % 2 == 0;
|
|
}
|
|
|
|
/// Add values of `register` and `A`, add +1 if carry arg is set (either false or state.cc.c)
|
|
pub fn add_reg<M: MemoryMapper>(register: Register, carry: bool, state: &mut EmulatorState<M>) {
|
|
add(get_register(register, state), carry, state);
|
|
}
|
|
|
|
/// Add values of input byte and `A`, add +1 if carry arg is set (either false or state.cc.c)
|
|
pub fn add<M: MemoryMapper>(byte: u8, carry: bool, state: &mut EmulatorState<M>) {
|
|
let (a, first) = state.a.overflowing_add(byte);
|
|
let (result, second) = a.overflowing_add(carry as u8);
|
|
|
|
state.cc.c = first != second;
|
|
set_cc(state, result);
|
|
state.a = result;
|
|
}
|
|
|
|
pub fn sub_reg<M: MemoryMapper>(register: Register, borrow: bool, state: &mut EmulatorState<M>) {
|
|
sub(get_register(register, state), borrow, state);
|
|
}
|
|
|
|
pub fn sub<M: MemoryMapper>(byte: u8, borrow: bool, state: &mut EmulatorState<M>) {
|
|
let (a, first) = state.a.overflowing_sub(byte);
|
|
let (result, second) = a.overflowing_sub(borrow as u8);
|
|
|
|
state.cc.c = first != second;
|
|
set_cc(state, result);
|
|
state.a = result;
|
|
}
|
|
|
|
macro_rules! bitwise_op {
|
|
($name:ident, $reg_name:ident, $op:tt) => {
|
|
pub fn $reg_name<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
$name(get_register(register, state), state);
|
|
}
|
|
|
|
pub fn $name<M: MemoryMapper>(byte: u8, state: &mut EmulatorState<M>) {
|
|
let result = state.a $op byte;
|
|
state.cc.c = false;
|
|
set_cc(state, result);
|
|
state.a = result;
|
|
}
|
|
}
|
|
}
|
|
|
|
bitwise_op!(and, and_reg, &);
|
|
bitwise_op!(or, or_reg, |);
|
|
bitwise_op!(xor, xor_reg, ^);
|
|
|
|
pub fn cmp_reg<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
cmp(get_register(register, state), state);
|
|
}
|
|
|
|
pub fn cmp<M: MemoryMapper>(byte: u8, state: &mut EmulatorState<M>) {
|
|
let (result, carry) = state.a.overflowing_sub(byte);
|
|
state.cc.c = carry;
|
|
set_cc(state, result);
|
|
}
|
|
|
|
/// Double precision add - Add B&C, D&E or H&L to H&L
|
|
pub fn dad<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
let num = get_register_pair(register, state);
|
|
let (result, overflow) = num.overflowing_add(u16::from_le_bytes([state.l, state.h]));
|
|
|
|
// this is the only 16-bit arithmetic function that sets the other flags
|
|
state.cc.z = result == 0;
|
|
state.cc.s = result & 0x8000 > 0;
|
|
state.cc.c = overflow;
|
|
state.cc.p = result.count_ones() % 2 == 0;
|
|
set_register_pair(register, result, state);
|
|
}
|
|
|
|
/// Increase register
|
|
pub fn inr<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
let (result, _) = get_register(register, state).overflowing_add(1);
|
|
set_cc(state, result);
|
|
set_register(register, result, state);
|
|
}
|
|
|
|
/// Decrease register
|
|
pub fn dcr<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
let (result, _) = get_register(register, state).overflowing_sub(1);
|
|
set_cc(state, result);
|
|
set_register(register, result, state);
|
|
}
|
|
|
|
/// Increase register pair
|
|
pub fn inx<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
let (result, _) = get_register_pair(register, state).overflowing_add(1);
|
|
set_register_pair(register, result, state);
|
|
}
|
|
|
|
/// Decrease register pair
|
|
pub fn dcx<M: MemoryMapper>(register: Register, state: &mut EmulatorState<M>) {
|
|
let (result, _) = get_register_pair(register, state).overflowing_sub(1);
|
|
set_register_pair(register, result, state);
|
|
}
|
|
|
|
pub fn rlc<M: MemoryMapper>(state: &mut EmulatorState<M>) {
|
|
let result = state.a.rotate_left(1);
|
|
state.a = result;
|
|
state.cc.c = result & 0x01 > 0;
|
|
}
|
|
|
|
pub fn rrc<M: MemoryMapper>(state: &mut EmulatorState<M>) {
|
|
state.cc.c = state.a & 0x01 > 0;
|
|
state.a = state.a.rotate_right(1);
|
|
}
|
|
|
|
pub fn ral<M: MemoryMapper>(state: &mut EmulatorState<M>) {
|
|
let new_carry = state.a & 0x80 > 0;
|
|
let result = state.a << 1;
|
|
state.a = result | new_carry as u8;
|
|
state.cc.c = new_carry;
|
|
}
|
|
|
|
pub fn rar<M: MemoryMapper>(state: &mut EmulatorState<M>) {
|
|
let new_carry = state.a & 0x01 > 0;
|
|
let result = state.a >> 1;
|
|
state.a = result | (new_carry as u8) << 7;
|
|
state.cc.c = new_carry;
|
|
}
|