parsons/ZXSpectrum48K
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented a shit load of OpCodes

Browse Source
This commit is contained in:
Marc Parsons
2026-04-15 00:27:15 +01:00
parent 695db41f60
commit 7e7453691f
2 changed files with 388 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
Core/Cpu/Z80.cs
View File

@@ -401,6 +401,34 @@ namespace Core.Cpu
if (result > 0xFF) AF.Low |= 0x01; if (result > 0xFF) AF.Low |= 0x01;
} }
private void AddA(byte operand)
{
byte a = AF.High;
int result = a + operand;
AF.High = (byte)result;
// --- Update Flags ---
AF.Low = 0; // Clear all flags initially (Forces N to 0)
// Sign Flag (Bit 7)
if ((AF.High & 0x80) != 0) AF.Low |= 0x80;
// Zero Flag (Bit 6)
if (AF.High == 0) AF.Low |= 0x40;
// Half-Carry Flag (Bit 4) - Check if bits 0-3 overflowed
if (((a & 0x0F) + (operand & 0x0F)) > 0x0F) AF.Low |= 0x10;
// Parity/Overflow Flag (Bit 2)
bool sameSign = ((a ^ operand) & 0x80) == 0; // Did inputs have the same sign?
bool changedSign = ((a ^ AF.High) & 0x80) != 0; // Did the result's sign flip?
if (sameSign && changedSign) AF.Low |= 0x04;
// Carry Flag (Bit 0) - Check if the whole 8-bit addition overflowed
if (result > 0xFF) AF.Low |= 0x01;
}
private bool HasEvenParity(byte value) private bool HasEvenParity(byte value)
{ {
int bits = 0; int bits = 0;
@@ -443,9 +471,15 @@ namespace Core.Cpu
case 0x01: // LD BC, nn case 0x01: // LD BC, nn
BC.Word = FetchWord(); BC.Word = FetchWord();
return 10; // Takes 10 T-States return 10; // Takes 10 T-States
case 0x03: // INC BC
BC.Word++;
return 6;
case 0x04: // INC B case 0x04: // INC B
BC.High = Inc8(BC.High); BC.High = Inc8(BC.High);
return 4; return 4;
case 0x0B: // DEC BC
BC.Word--;
return 6;
case 0x0E: // LD C, n case 0x0E: // LD C, n
BC.Low = FetchByte(); BC.Low = FetchByte();
return 7; // Takes 7 T-States return 7; // Takes 7 T-States
@@ -464,6 +498,9 @@ namespace Core.Cpu
case 0x11: //LD DE, nn case 0x11: //LD DE, nn
DE.Word = FetchWord(); DE.Word = FetchWord();
return 10; return 10;
case 0x13: // INC DE
DE.Word++;
return 6;
case 0x16: // LD D, n case 0x16: // LD D, n
DE.High = FetchByte(); DE.High = FetchByte();
return 7; return 7;
@@ -539,6 +576,9 @@ namespace Core.Cpu
_memory.Write(destAddress, AF.High); _memory.Write(destAddress, AF.High);
return 13; return 13;
} }
case 0x33: // INC SP
SP++;
return 6;
case 0x35: // DEC (HL) case 0x35: // DEC (HL)
// Read the current byte from memory // Read the current byte from memory
byte memValue = _memory.Read(HL.Word); byte memValue = _memory.Read(HL.Word);
@@ -567,6 +607,9 @@ namespace Core.Cpu
return 12; return 12;
} }
return 7; return 7;
case 0x3B: // DEC SP
SP--;
return 6;
case 0x3E: //LD A, n case 0x3E: //LD A, n
AF.High = FetchByte(); AF.High = FetchByte();
return 7; return 7;
@@ -580,76 +623,144 @@ namespace Core.Cpu
else else
AF.Low &= 0xEF; AF.Low &= 0xEF;
return 4; return 4;
case 0x47: // LD B, A case 0x40: BC.High = BC.High; return 4;
BC.High = AF.High; case 0x41: BC.High = BC.Low; return 4;
return 4; case 0x42: BC.High = DE.High; return 4;
case 0x4E: // LD C, (HL) case 0x43: BC.High = DE.Low; return 4;
BC.Low = _memory.Read(HL.Word); case 0x44: BC.High = HL.High; return 4;
return 7; case 0x45: BC.High = HL.Low; return 4;
case 0x56: // LD D, (HL) case 0x46: BC.High = _memory.Read(HL.Word); return 7;
DE.High = _memory.Read(HL.Word); case 0x47: BC.High = AF.High; return 4;
return 7; // Takes 7 T-States
case 0x5E: // LD E, (HL) // --- LD C, r ---
DE.Low = _memory.Read(HL.Word); case 0x48: BC.Low = BC.High; return 4;
return 7; // Takes 7 T-States case 0x49: BC.Low = BC.Low; return 4;
case 0x62: // LD H, D case 0x4A: BC.Low = DE.High; return 4;
HL.High = DE.High; case 0x4B: BC.Low = DE.Low; return 4;
return 4; case 0x4C: BC.Low = HL.High; return 4;
case 0x67: // LD H, A case 0x4D: BC.Low = HL.Low; return 4;
HL.High = AF.High; case 0x4E: BC.Low = _memory.Read(HL.Word); return 7;
return 4; case 0x4F: BC.Low = AF.High; return 4;
case 0x6B: // LD L, E
HL.Low = DE.Low; // --- LD D, r ---
return 4; case 0x50: DE.High = BC.High; return 4;
case 0x72: // LD (HL), D case 0x51: DE.High = BC.Low; return 4;
_memory.Write(HL.Word, DE.High); case 0x52: DE.High = DE.High; return 4;
return 7; case 0x53: DE.High = DE.Low; return 4;
case 0x73: // LD (HL), E case 0x54: DE.High = HL.High; return 4;
_memory.Write(HL.Word, DE.Low); case 0x55: DE.High = HL.Low; return 4;
return 7; case 0x56: DE.High = _memory.Read(HL.Word); return 7;
case 0x77: // LD (HL), A case 0x57: DE.High = AF.High; return 4;
_memory.Write(HL.Word, AF.High);
return 7; // --- LD E, r ---
case 0x7A: // LD A, D case 0x58: DE.Low = BC.High; return 4;
AF.High = DE.High; case 0x59: DE.Low = BC.Low; return 4;
return 4; case 0x5A: DE.Low = DE.High; return 4;
case 0x7E: // LD A, (HL) case 0x5B: DE.Low = DE.Low; return 4;
AF.High = _memory.Read(HL.Word); case 0x5C: DE.Low = HL.High; return 4;
return 7; // Takes 7 T-States case 0x5D: DE.Low = HL.Low; return 4;
case 0x87: // ADD A, A case 0x5E: DE.Low = _memory.Read(HL.Word); return 7;
Add(AF.High); case 0x5F: DE.Low = AF.High; return 4;
return 4;
case 0x91: // SUB C // --- LD H, r ---
Sub(BC.Low); case 0x60: HL.High = BC.High; return 4;
return 4; case 0x61: HL.High = BC.Low; return 4;
case 0xA7: // AND A case 0x62: HL.High = DE.High; return 4;
And(AF.High); case 0x63: HL.High = DE.Low; return 4;
return 4; case 0x64: HL.High = HL.High; return 4;
case 0x5F: // LD E, A case 0x65: HL.High = HL.Low; return 4;
DE.Low = AF.High; case 0x66: HL.High = _memory.Read(HL.Word); return 7;
return 4; case 0x67: HL.High = AF.High; return 4;
case 0x6F: // LD L, A
HL.Low = AF.High; // --- LD L, r ---
return 4; case 0x68: HL.Low = BC.High; return 4;
case 0xAE: // XOR (HL) case 0x69: HL.Low = BC.Low; return 4;
Xor(_memory.Read(HL.Word)); case 0x6A: HL.Low = DE.High; return 4;
return 7; case 0x6B: HL.Low = DE.Low; return 4;
case 0xAF: // XOR A case 0x6C: HL.Low = HL.High; return 4;
AF.High = 0; case 0x6D: HL.Low = HL.Low; return 4;
AF.Low = 0x44; case 0x6E: HL.Low = _memory.Read(HL.Word); return 7;
return 4; case 0x6F: HL.Low = AF.High; return 4;
case 0xB3: // OR E
Or(DE.Low); // --- LD (HL), r --- (Note: 0x76 is HALT, so it is skipped here)
return 4; case 0x70: _memory.Write(HL.Word, BC.High); return 7;
case 0xB9: // CP C case 0x71: _memory.Write(HL.Word, BC.Low); return 7;
Cp(BC.Low); case 0x72: _memory.Write(HL.Word, DE.High); return 7;
return 4; // Takes 4 T-States case 0x73: _memory.Write(HL.Word, DE.Low); return 7;
case 0xBC: // CP H case 0x74: _memory.Write(HL.Word, HL.High); return 7;
Cp(HL.High); case 0x75: _memory.Write(HL.Word, HL.Low); return 7;
return 4; case 0x77: _memory.Write(HL.Word, AF.High); return 7;
// --- LD A, r ---
case 0x78: AF.High = BC.High; return 4;
case 0x79: AF.High = BC.Low; return 4;
case 0x7A: AF.High = DE.High; return 4;
case 0x7B: AF.High = DE.Low; return 4;
case 0x7C: AF.High = HL.High; return 4;
case 0x7D: AF.High = HL.Low; return 4;
case 0x7E: AF.High = _memory.Read(HL.Word); return 7;
case 0x7F: AF.High = AF.High; return 4;
case 0x80: Add(BC.High); return 4; // ADD A, B
case 0x81: Add(BC.Low); return 4; // ADD A, C
case 0x82: Add(DE.High); return 4; // ADD A, D
case 0x83: Add(DE.Low); return 4; // ADD A, E
case 0x84: Add(HL.High); return 4; // ADD A, H
case 0x85: Add(HL.Low); return 4; // ADD A, L
case 0x86: Add(_memory.Read(HL.Word)); return 7; // ADD A, (HL)
case 0x87: Add(AF.High); return 4; // ADD A, A
case 0x90: Sub(BC.High); return 4; // SUB B
case 0x91: Sub(BC.Low); return 4; // SUB C
case 0x92: Sub(DE.High); return 4; // SUB D
case 0x93: Sub(DE.Low); return 4; // SUB E
case 0x94: Sub(HL.High); return 4; // SUB H
case 0x95: Sub(HL.Low); return 4; // SUB L
case 0x96: Sub(_memory.Read(HL.Word)); return 7; // SUB (HL)
case 0x97: Sub(AF.High); return 4; // SUB A
case 0xA0: And(BC.High); return 4; // AND B
case 0xA1: And(BC.Low); return 4; // AND C
case 0xA2: And(DE.High); return 4; // AND D
case 0xA3: And(DE.Low); return 4; // AND E
case 0xA4: And(HL.High); return 4; // AND H
case 0xA5: And(HL.Low); return 4; // AND L
case 0xA6: And(_memory.Read(HL.Word)); return 7; // AND (HL)
case 0xA7: And(AF.High); return 4; // AND A
case 0xA8: Xor(BC.High); return 4; // XOR B
case 0xA9: Xor(BC.Low); return 4; // XOR C
case 0xAA: Xor(DE.High); return 4; // XOR D
case 0xAB: Xor(DE.Low); return 4; // XOR E
case 0xAC: Xor(HL.High); return 4; // XOR H
case 0xAD: Xor(HL.Low); return 4; // XOR L
case 0xAE: Xor(_memory.Read(HL.Word)); return 7; // XOR (HL)
case 0xAF: Xor(AF.High); return 4; // XOR A
// --- OR r ---
case 0xB0: Or(BC.High); return 4; // OR B
case 0xB1: Or(BC.Low); return 4; // OR C
case 0xB2: Or(DE.High); return 4; // OR D
case 0xB3: Or(DE.Low); return 4; // OR E
case 0xB4: Or(HL.High); return 4; // OR H
case 0xB5: Or(HL.Low); return 4; // OR L
case 0xB6: Or(_memory.Read(HL.Word)); return 7; // OR (HL)
case 0xB7: Or(AF.High); return 4; // OR A
// --- CP r ---
case 0xB8: Cp(BC.High); return 4; // CP B
case 0xB9: Cp(BC.Low); return 4; // CP C
case 0xBA: Cp(DE.High); return 4; // CP D
case 0xBB: Cp(DE.Low); return 4; // CP E
case 0xBC: Cp(HL.High); return 4; // CP H
case 0xBD: Cp(HL.Low); return 4; // CP L
case 0xBE: Cp(_memory.Read(HL.Word)); return 7; // CP (HL)
case 0xBF: Cp(AF.High); return 4; // CP A
case 0xC1: // POP BC
BC.Word = Pop();
return 10;
case 0xC3: case 0xC3:
PC = FetchWord(); PC = FetchWord();
return 10; return 10;
case 0xc5: //push bc
Push(BC.Word);
return 11;
case 0xC6: // ADD A, n case 0xC6: // ADD A, n
Add(FetchByte()); Add(FetchByte());
return 7; return 7;
@@ -677,6 +788,9 @@ namespace Core.Cpu
return 11; // Condition met, took the return return 11; // Condition met, took the return
} }
return 5; // Condition not met, skipped return 5; // Condition not met, skipped
case 0xD1: // POP DE
DE.Word = Pop();
return 10;
case 0xD3: // OUT (n), A case 0xD3: // OUT (n), A
byte portOffset = FetchByte(); byte portOffset = FetchByte();
@@ -685,7 +799,13 @@ namespace Core.Cpu
_ioBus.Write(portAddress, AF.High); _ioBus.Write(portAddress, AF.High);
return 11; // Takes 11 T-States return 11;
case 0xd5: //push bc
Push(DE.Word);
return 11;
case 0xD6: // SUB n
Sub(FetchByte());
return 7;
case 0xD9: // EXX case 0xD9: // EXX
ushort tempBC = BC.Word; ushort tempBC = BC.Word;
BC.Word = BC_Prime.Word; BC.Word = BC_Prime.Word;
@@ -703,6 +823,12 @@ namespace Core.Cpu
case 0xDE: // SBC A, n case 0xDE: // SBC A, n
Sbc(FetchByte()); Sbc(FetchByte());
return 7; return 7;
case 0xE1: // POP HL
HL.Word = Pop();
return 10;
case 0xe5: //push bc
Push(HL.Word);
return 11;
case 0xE6: // AND n case 0xE6: // AND n
And(FetchByte()); And(FetchByte());
return 7; return 7;
@@ -716,10 +842,16 @@ namespace Core.Cpu
return 4; // Takes 4 T-States return 4; // Takes 4 T-States
case 0xED: case 0xED:
return ExecuteExtendedPrefix(); return ExecuteExtendedPrefix();
case 0xF1: // POP AF
AF.Word = Pop();
return 10;
case 0xF3: // DI (Disable Interrupts) case 0xF3: // DI (Disable Interrupts)
IFF1 = false; IFF1 = false;
IFF2 = false; IFF2 = false;
return 4; return 4;
case 0xf5: //push bc
Push(AF.Word);
return 11;
case 0xF9: // LD SP, HL case 0xF9: // LD SP, HL
SP = HL.Word; // (Use SP.Word = HL.Word if you made SP a RegisterPair) SP = HL.Word; // (Use SP.Word = HL.Word if you made SP a RegisterPair)
return 6; return 6;
@@ -870,6 +1002,16 @@ namespace Core.Cpu
// Write the low byte of HL to memory // Write the low byte of HL to memory
_memory.Write(targetAddress, HL.Low); _memory.Write(targetAddress, HL.Low);
return 19; return 19;
case 0x86: // ADD A, (IY+d)
{
sbyte displacementAdd = (sbyte)FetchByte();
ushort targetAddressAdd = (ushort)(IY.Word + displacementAdd);
byte valueToAdd = _memory.Read(targetAddressAdd);
AddA(valueToAdd);
return 19;
}
case 0xCB: // The FD CB nested prefix case 0xCB: // The FD CB nested prefix
{ {
sbyte offsetCB = (sbyte)FetchByte(); // This is the '01' sbyte offsetCB = (sbyte)FetchByte(); // This is the '01'

243
Desktop/DebuggerForm.cs
View File

@@ -256,6 +256,14 @@ namespace Desktop
mnemonic = $"LD BC, 0x{bcVal:X4}"; mnemonic = $"LD BC, 0x{bcVal:X4}";
instructionLength = 3; instructionLength = 3;
break; break;
// --- 16-Bit Increments ---
case 0x03: mnemonic = "INC BC"; break;
case 0x13: mnemonic = "INC DE"; break;
case 0x33: mnemonic = "INC SP"; break;
// --- 16-Bit Decrements ---
case 0x0B: mnemonic = "DEC BC"; break;
case 0x3B: mnemonic = "DEC SP"; break;
case 0x04: case 0x04:
mnemonic = "INC B"; mnemonic = "INC B";
break; break;
@@ -376,72 +384,145 @@ namespace Desktop
case 0x3F: case 0x3F:
mnemonic = "CCF"; mnemonic = "CCF";
break; break;
case 0x47: // --- LD B, r ---
mnemonic = "LD B, A"; case 0x40: mnemonic = "LD B, B"; break;
break; case 0x41: mnemonic = "LD B, C"; break;
case 0x4E: case 0x42: mnemonic = "LD B, D"; break;
mnemonic = "LD C, (HL)"; case 0x43: mnemonic = "LD B, E"; break;
break; case 0x44: mnemonic = "LD B, H"; break;
case 0x56: case 0x45: mnemonic = "LD B, L"; break;
mnemonic = "LD D, (HL)"; case 0x46: mnemonic = "LD B, (HL)"; break;
break; case 0x47: mnemonic = "LD B, A"; break;
case 0x5E:
mnemonic = "LD E, (HL)"; // --- LD C, r ---
break; case 0x48: mnemonic = "LD C, B"; break;
case 0x5F: case 0x49: mnemonic = "LD C, C"; break;
mnemonic = "LD E, A"; case 0x4A: mnemonic = "LD C, D"; break;
break; case 0x4B: mnemonic = "LD C, E"; break;
case 0x62: case 0x4C: mnemonic = "LD C, H"; break;
mnemonic = "LD H, D"; case 0x4D: mnemonic = "LD C, L"; break;
break; case 0x4E: mnemonic = "LD C, (HL)"; break;
case 0x67: case 0x4F: mnemonic = "LD C, A"; break;
mnemonic = "LD H, A";
break; // --- LD D, r ---
case 0x6B: case 0x50: mnemonic = "LD D, B"; break;
mnemonic = "LD L, E"; case 0x51: mnemonic = "LD D, C"; break;
break; case 0x52: mnemonic = "LD D, D"; break;
case 0x6F: case 0x53: mnemonic = "LD D, E"; break;
mnemonic = "LD L, A"; case 0x54: mnemonic = "LD D, H"; break;
break; case 0x55: mnemonic = "LD D, L"; break;
case 0x72: case 0x56: mnemonic = "LD D, (HL)"; break;
mnemonic = "LD (HL), D"; case 0x57: mnemonic = "LD D, A"; break;
break;
case 0x73: // --- LD E, r ---
mnemonic = "LD (HL), E"; case 0x58: mnemonic = "LD E, B"; break;
break; case 0x59: mnemonic = "LD E, C"; break;
case 0x77: case 0x5A: mnemonic = "LD E, D"; break;
mnemonic = "LD (HL), A"; case 0x5B: mnemonic = "LD E, E"; break;
break; case 0x5C: mnemonic = "LD E, H"; break;
case 0x7A: case 0x5D: mnemonic = "LD E, L"; break;
mnemonic = "LD A, D"; case 0x5E: mnemonic = "LD E, (HL)"; break;
break; case 0x5F: mnemonic = "LD E, A"; break;
case 0x7E:
mnemonic = "LD A, (HL)"; // --- LD H, r ---
break; case 0x60: mnemonic = "LD H, B"; break;
case 0x87: case 0x61: mnemonic = "LD H, C"; break;
mnemonic = "ADD A, A"; case 0x62: mnemonic = "LD H, D"; break;
break; case 0x63: mnemonic = "LD H, E"; break;
case 0x91: case 0x64: mnemonic = "LD H, H"; break;
mnemonic = "SUB C"; case 0x65: mnemonic = "LD H, L"; break;
break; case 0x66: mnemonic = "LD H, (HL)"; break;
case 0xA7: case 0x67: mnemonic = "LD H, A"; break;
mnemonic = "AND A";
break; // --- LD L, r ---
case 0xAE: case 0x68: mnemonic = "LD L, B"; break;
mnemonic = "XOR (HL)"; case 0x69: mnemonic = "LD L, C"; break;
break; case 0x6A: mnemonic = "LD L, D"; break;
case 0xAF: case 0x6B: mnemonic = "LD L, E"; break;
mnemonic = "XOR A"; case 0x6C: mnemonic = "LD L, H"; break;
break; case 0x6D: mnemonic = "LD L, L"; break;
case 0xB3: case 0x6E: mnemonic = "LD L, (HL)"; break;
mnemonic = "OR E"; case 0x6F: mnemonic = "LD L, A"; break;
break;
case 0xB9: // --- LD (HL), r --- (Note: 0x76 is HALT, so it is skipped)
mnemonic = "CP C"; case 0x70: mnemonic = "LD (HL), B"; break;
break; case 0x71: mnemonic = "LD (HL), C"; break;
case 0xBC: case 0x72: mnemonic = "LD (HL), D"; break;
mnemonic = "CP H"; case 0x73: mnemonic = "LD (HL), E"; break;
break; case 0x74: mnemonic = "LD (HL), H"; break;
case 0x75: mnemonic = "LD (HL), L"; break;
case 0x77: mnemonic = "LD (HL), A"; break;
// --- LD A, r ---
case 0x78: mnemonic = "LD A, B"; break;
case 0x79: mnemonic = "LD A, C"; break;
case 0x7A: mnemonic = "LD A, D"; break;
case 0x7B: mnemonic = "LD A, E"; break;
case 0x7C: mnemonic = "LD A, H"; break;
case 0x7D: mnemonic = "LD A, L"; break;
case 0x7E: mnemonic = "LD A, (HL)"; break;
case 0x7F: mnemonic = "LD A, A"; break;
// --- ADD A, r ---
case 0x80: mnemonic = "ADD A, B"; break;
case 0x81: mnemonic = "ADD A, C"; break;
case 0x82: mnemonic = "ADD A, D"; break;
case 0x83: mnemonic = "ADD A, E"; break;
case 0x84: mnemonic = "ADD A, H"; break;
case 0x85: mnemonic = "ADD A, L"; break;
case 0x86: mnemonic = "ADD A, (HL)"; break;
case 0x87: mnemonic = "ADD A, A"; break;
// --- SUB r ---
case 0x90: mnemonic = "SUB B"; break;
case 0x91: mnemonic = "SUB C"; break;
case 0x92: mnemonic = "SUB D"; break;
case 0x93: mnemonic = "SUB E"; break;
case 0x94: mnemonic = "SUB H"; break;
case 0x95: mnemonic = "SUB L"; break;
case 0x96: mnemonic = "SUB (HL)"; break;
case 0x97: mnemonic = "SUB A"; break;
// --- AND r ---
case 0xA0: mnemonic = "AND B"; break;
case 0xA1: mnemonic = "AND C"; break;
case 0xA2: mnemonic = "AND D"; break;
case 0xA3: mnemonic = "AND E"; break;
case 0xA4: mnemonic = "AND H"; break;
case 0xA5: mnemonic = "AND L"; break;
case 0xA6: mnemonic = "AND (HL)"; break;
case 0xA7: mnemonic = "AND A"; break;
// --- XOR r ---
case 0xA8: mnemonic = "XOR B"; break;
case 0xA9: mnemonic = "XOR C"; break;
case 0xAA: mnemonic = "XOR D"; break;
case 0xAB: mnemonic = "XOR E"; break;
case 0xAC: mnemonic = "XOR H"; break;
case 0xAD: mnemonic = "XOR L"; break;
case 0xAE: mnemonic = "XOR (HL)"; break;
case 0xAF: mnemonic = "XOR A"; break;
// --- OR r ---
case 0xB0: mnemonic = "OR B"; break;
case 0xB1: mnemonic = "OR C"; break;
case 0xB2: mnemonic = "OR D"; break;
case 0xB3: mnemonic = "OR E"; break;
case 0xB4: mnemonic = "OR H"; break;
case 0xB5: mnemonic = "OR L"; break;
case 0xB6: mnemonic = "OR (HL)"; break;
case 0xB7: mnemonic = "OR A"; break;
// --- CP r ---
case 0xB8: mnemonic = "CP B"; break;
case 0xB9: mnemonic = "CP C"; break;
case 0xBA: mnemonic = "CP D"; break;
case 0xBB: mnemonic = "CP E"; break;
case 0xBC: mnemonic = "CP H"; break;
case 0xBD: mnemonic = "CP L"; break;
case 0xBE: mnemonic = "CP (HL)"; break;
case 0xBF: mnemonic = "CP A"; break;
case 0xC1: mnemonic = "POP BC"; break;
case 0xC3: case 0xC3:
// JP nn // JP nn
byte jpLow = _memoryBus.Read((ushort)(currentPc + 1)); byte jpLow = _memoryBus.Read((ushort)(currentPc + 1));
@@ -449,6 +530,9 @@ namespace Desktop
mnemonic = $"JP 0x{jpHigh:X2}{jpLow:X2}"; mnemonic = $"JP 0x{jpHigh:X2}{jpLow:X2}";
instructionLength = 3; instructionLength = 3;
break; break;
case 0xc5:
mnemonic = "PUSH BC";
break;
case 0xC6: case 0xC6:
{ {
byte addImm = _memoryBus.Read((ushort)(currentPc + 1)); byte addImm = _memoryBus.Read((ushort)(currentPc + 1));
@@ -470,6 +554,7 @@ namespace Desktop
case 0xD0: case 0xD0:
mnemonic = "RET NC"; mnemonic = "RET NC";
break; break;
case 0xD1: mnemonic = "POP DE"; break;
case 0xD3: case 0xD3:
byte outPort = _memoryBus.Read((ushort)(currentPc + 1)); byte outPort = _memoryBus.Read((ushort)(currentPc + 1));
mnemonic = $"OUT (0x{outPort:X2}), A"; mnemonic = $"OUT (0x{outPort:X2}), A";
@@ -478,11 +563,24 @@ namespace Desktop
case 0xD9: case 0xD9:
mnemonic = "EXX"; mnemonic = "EXX";
break; break;
break;
case 0xd5:
mnemonic = "PUSH DE";
break;
case 0xD6:
byte subImm = _memoryBus.Read((ushort)(currentPc + 1));
mnemonic = $"SUB 0x{subImm:X2}";
instructionLength = 2;
break;
case 0xDE: case 0xDE:
byte sbcValue = _memoryBus.Read((ushort)(currentPc + 1)); byte sbcValue = _memoryBus.Read((ushort)(currentPc + 1));
mnemonic = $"SBC A, 0x{sbcValue:X2}"; mnemonic = $"SBC A, 0x{sbcValue:X2}";
instructionLength = 2; instructionLength = 2;
break; break;
case 0xE1: mnemonic = "POP HL"; break;
case 0xE5:
mnemonic = "PUSH HL";
break;
case 0xE6: case 0xE6:
byte andImm = _memoryBus.Read((ushort)(currentPc + 1)); byte andImm = _memoryBus.Read((ushort)(currentPc + 1));
mnemonic = $"AND 0x{andImm:X2}"; mnemonic = $"AND 0x{andImm:X2}";
@@ -536,9 +634,14 @@ namespace Desktop
break; break;
} }
break; break;
case 0xF1: mnemonic = "POP AF"; break;
case 0xF3: case 0xF3:
mnemonic = "DI"; mnemonic = "DI";
break; break;
break;
case 0xf5:
mnemonic = "PUSH AF";
break;
case 0xF9: case 0xF9:
mnemonic = "LD SP, HL"; mnemonic = "LD SP, HL";
break; break;
@@ -578,6 +681,14 @@ namespace Desktop
mnemonic = $"LD L, (IY{signL}{offsetL})"; mnemonic = $"LD L, (IY{signL}{offsetL})";
instructionLength = 3; instructionLength = 3;
} }
else if (fdOpcode == 0x86) // ADD A, (IY+d)
{
sbyte dAdd = (sbyte)_memoryBus.Read((ushort)(currentPc + 2));
string signAdd = dAdd >= 0 ? "+" : "";
mnemonic = $"ADD A, (IY{signAdd}{dAdd})";
instructionLength = 3;
}
else if (fdOpcode == 0xCB) // FD CB prefix else if (fdOpcode == 0xCB) // FD CB prefix
{ {
sbyte d = (sbyte)_memoryBus.Read((ushort)(currentPc + 2)); sbyte d = (sbyte)_memoryBus.Read((ushort)(currentPc + 2));