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); } }