public void JumpToAddress(byte addrHigh, byte addrLow, ref ushort pc)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
//JumpToAddress(address, ref pc); //TODO Should not cause ticks?
pc = address;
}
public void Push(ref ushort pointer, byte valueHigh, byte valueLow)
{
pointer -= 2;
TickEvent?.Invoke();
memory.WriteWord(pointer, BitUtils.BytesToUshort(valueHigh, valueLow));
TickEvent?.Invoke();
TickEvent?.Invoke();
}
public void DecrementWord(ref ushort target)
{
byte high = BitUtils.MostSignificantByte(target);
byte low = BitUtils.LeastSignificantByte(target);
DecrementWord(ref high, ref low);
target = BitUtils.BytesToUshort(high, low);
}
public void DecrementWord(ref byte targetHigh, ref byte targetLow)
{
ushort target = BitUtils.BytesToUshort(targetHigh, targetLow);
target = (ushort)(target - 1);
targetHigh = BitUtils.MostSignificantByte(target);
targetLow = BitUtils.LeastSignificantByte(target);
TickEvent?.Invoke();
}
public void RotateLeftThroughCarry(byte addrHigh, byte addrLow, ref byte flags)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
byte data = memory.ReadByte(address);
TickEvent?.Invoke();
RotateLeftThroughCarry(ref data, ref flags, false);
memory.WriteByte(address, data);
TickEvent?.Invoke();
}
public void Swap(byte addrHigh, byte addrLow, ref byte flags)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
byte data = memory.ReadByte(address);
TickEvent?.Invoke();
Swap(ref data, ref flags);
memory.WriteByte(address, data);
TickEvent?.Invoke();
}
public void SetBit(byte addrHigh, byte addrLow, int index, bool bit)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
byte data = memory.ReadByte(address);
TickEvent?.Invoke();
SetBit(ref data, index, bit);
memory.WriteByte(address, data);
TickEvent?.Invoke();
}
public void WriteToAddressAndIncrement(ref byte addrHigh, ref byte addrLow, byte value, short addValue)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
memory.WriteByte(address, value);
TickEvent?.Invoke();
address = (ushort)(address + addValue);
addrHigh = BitUtils.MostSignificantByte(address);
addrLow = BitUtils.LeastSignificantByte(address);
}
public void LoadFromAddressAndIncrement(ref byte dest, ref byte addrHigh, ref byte addrLow, short value)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
dest = memory.ReadByte(address);
TickEvent?.Invoke();
address = (ushort)(address + value);
addrHigh = BitUtils.MostSignificantByte(address);
addrLow = BitUtils.LeastSignificantByte(address);
}
public void DecrementInMemory(byte addrHigh, byte addrLow, ref byte flags)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
byte origValue = memory.ReadByte(address);
TickEvent?.Invoke();
memory.WriteByte(address, (byte)(origValue - 1));
FlagUtils.SetFlag(Flag.Z, (byte)(origValue - 1) == 0, ref flags);
FlagUtils.SetFlag(Flag.N, true, ref flags);
FlagUtils.SetFlag(Flag.H, (origValue & 0x0F) < 1, ref flags);
TickEvent?.Invoke();
}
public void Add(ref byte toHigh, ref byte toLow, byte valueHigh, byte valueLow, ref byte flags)
{
ushort to = BitUtils.BytesToUshort(toHigh, toLow);
ushort value = BitUtils.BytesToUshort(valueHigh, valueLow);
ushort result = (ushort)((to + value) & 0xFFFF);
toHigh = BitUtils.MostSignificantByte(result);
toLow = BitUtils.LeastSignificantByte(result);
// Zero flag is not affected
FlagUtils.SetFlag(Flag.N, false, ref flags);
FlagUtils.SetFlag(Flag.H, (to & 0xFFF) + (value & 0xFFF) > 0xFFF, ref flags);
FlagUtils.SetFlag(Flag.C, to + value > 0xFFFF, ref flags);
TickEvent?.Invoke();
}
public void LoadAdjustedPositiveTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte H = 0xF0;
byte L = 0xF0;
ushort SP = 0x0000;
byte flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x0001;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0002, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x000F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0010, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x0010;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0011, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x001F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0020, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x007F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0080, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x0080;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0081, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x00FF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0100, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
SP = 0x0100;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0101, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x0F00;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0F01, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x1F00;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x1F01, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x1000;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x1001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x7FFF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x8000, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
SP = 0x8000;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x8001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0xFFFF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0000, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
}
public void WriteToAddress(byte addrHigh, byte addrLow, byte value)
{
WriteToAddress(BitUtils.BytesToUshort(addrHigh, addrLow), value);
}
public void LoadFromAddress(ref byte dest, byte addrHigh, byte addrLow)
{
LoadFromAddress(ref dest, BitUtils.BytesToUshort(addrHigh, addrLow));
}
public void Load(ref ushort dest, byte valueHigh, byte valueLow)
{
dest = BitUtils.BytesToUshort(valueHigh, valueLow);
TickEvent?.Invoke();
}
public void BytesToUshortTest()
{
ushort result = BitUtils.BytesToUshort(0xAA, 0xFF);
Assert.Equal(0xAAFF, result);
}
