public void ShiftRightLogic(ref byte target, ref byte flags)
{
bool carry = (target & 1) > 0;
target = (byte)(target >> 1);
FlagUtils.SetFlags(ref flags, target == 0, false, false, carry);
}
public void ShiftLeftArithmetic(ref byte target, ref byte flags)
{
bool setCarry = (target & 0x80) > 0;
target = (byte)((target << 1) & 0xFF);
FlagUtils.SetFlags(ref flags, target == 0, false, false, setCarry);
}
public void Swap(ref byte register, ref byte flags)
{
int lower = register & 0xF;
int higher = register & 0xF0;
register = (byte)(higher >> 4 | lower << 4);
FlagUtils.SetFlags(ref flags, register == 0, false, false, false);
}
public void ShiftRightArithmetic(ref byte target, ref byte flags)
{
byte msb = (byte)(target & 0x80);
bool setCarry = (target & 1) > 0;
target = (byte)((target >> 1) | msb);
FlagUtils.SetFlags(ref flags, target == 0, false, false, setCarry);
}
public void RotateRightThroughCarry(ref byte register, ref byte flags, bool alwaysResetZero)
{
int carry = FlagUtils.GetFlag(Flag.C, flags) ? 0x80 : 0x0;
bool setCarry = register.IsBitSet(0);
register = (byte)((register >> 1) | carry);
FlagUtils.SetFlags(ref flags, !alwaysResetZero && register == 0, false, false, setCarry);
}
public void Xor(ref byte to, byte value, ref byte flags)
{
to = (byte)(to ^ value);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
false,
false);
}
public void And(ref byte to, byte value, ref byte flags)
{
to = (byte)(to & value);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
true,
false);
}
public void PopWithFlags(ref byte valueHigh, ref byte valueLow, ref ushort pointer, ref byte flags)
{
Pop(ref valueHigh, ref valueLow, ref pointer);
FlagUtils.SetFlags(ref flags,
valueLow.IsBitSet(7),
valueLow.IsBitSet(6),
valueLow.IsBitSet(5),
valueLow.IsBitSet(4));
flags = (byte)(flags & 0xF0);
}
public void Compare(byte to, byte value, ref byte flags)
{
byte result = (byte)((to - value) & 0xFF);
FlagUtils.SetFlags(ref flags,
result == 0,
true,
(to & 0x0F) < (value & 0x0F),
to < value);
}
public void ResetFlagsTest()
{
byte flags = 0b01010000;
FlagUtils.SetFlags(ref flags,
false,
false,
false,
false);
Assert.Equal(0b00000000, flags);
}
public void SetFlagTest()
{
byte flags = 0b01110000;
FlagUtils.SetFlags(ref flags,
true,
true,
true,
true);
Assert.Equal(0b11110000, flags);
}
public void Subtract(ref byte from, byte value, ref byte flags, bool subtractCarryFlag = false)
{
int additionalValue = subtractCarryFlag && FlagUtils.GetFlag(Flag.C, flags) ? 1 : 0;
byte origValue = from;
int newValue = from - value - additionalValue;
from = (byte)(newValue & 0xFF);
FlagUtils.SetFlags(ref flags,
from == 0,
true,
(origValue & 0x0F) - (value & 0xF) - (additionalValue & 0xF) < 0,
origValue < (value + additionalValue));
}
public void Add(ref byte to, byte value, ref byte flags, bool addCarryFlag = false)
{
int additionalValue = addCarryFlag && FlagUtils.GetFlag(Flag.C, flags) ? 1 : 0;
byte origValue = to;
int newValue = to + value + additionalValue;
to = (byte)(newValue & 0xFF);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
(origValue & 0x0F) + (value & 0x0F) + additionalValue > 0x0F,
newValue > 0xFF);
}
public void RotateRight(ref byte register, ref byte flags, bool alwaysResetZero)
{
bool setCarry = register.IsBitSet(0);
register = (byte)((register >> 1) | (setCarry ? 1 << 7 : 0));
if (alwaysResetZero)
{
FlagUtils.SetFlags(ref flags, false, false, false, setCarry);
}
else
{
FlagUtils.SetFlags(ref flags, register == 0, false, false, setCarry);
}
}
