toni/emu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace READ_ADDR

Browse Source
This commit is contained in:
Antoni Piasecki
2025-07-13 20:16:55 +02:00
parent b24fc558cc
commit 2f2d9cf8ee
1 changed files with 128 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
mos6502.c
View File

@@ -4,10 +4,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define READ_ADDR() \ #define READ_U8() m->memory[m->pc++]
uint16_t low = m->memory[m->pc++]; \ #define READ_U16() (READ_U8() | (READ_U8() << 8))
uint16_t high = m->memory[m->pc++]; \
uint16_t addr = (high << 8) | low
typedef struct MOS6502 { typedef struct MOS6502 {
uint8_t *memory; uint8_t *memory;
@@ -31,263 +29,239 @@ void mos6502_disassemble(MOS6502 *m, size_t program_size) {
while (m->pc < 0x600 + program_size) { while (m->pc < 0x600 + program_size) {
printf("%04X: ", m->pc); printf("%04X: ", m->pc);
uint8_t op = m->memory[m->pc++]; uint8_t op = READ_U8();
switch (op) { switch (op) {
case 0x00: { case 0x00: {
printf("BRK\n"); printf("BRK\n");
} break; } break;
case 0x01: { case 0x01: {
printf("ORA ($%02X,X)\n", m->memory[m->pc++]); printf("ORA ($%02X,X)\n", READ_U8());
} break; } break;
case 0x05: { case 0x05: {
printf("ORA $%02X\n", m->memory[m->pc++]); printf("ORA $%02X\n", READ_U8());
} break; } break;
case 0x06: { case 0x06: {
printf("ASL $%02X\n", m->memory[m->pc++]); printf("ASL $%02X\n", READ_U8());
} break; } break;
case 0x08: { case 0x08: {
printf("PHP\n"); printf("PHP\n");
} break; } break;
case 0x09: { case 0x09: {
printf("ORA #$%02X\n", m->memory[m->pc++]); printf("ORA #$%02X\n", READ_U8());
} break; } break;
case 0x0A: { case 0x0A: {
printf("ASL A\n"); printf("ASL A\n");
} break; } break;
case 0x0D: { case 0x0D: {
READ_ADDR(); printf("ORA $%04X\n", READ_U16());
printf("ORA $%04X\n", addr);
} break; } break;
case 0x0E: { case 0x0E: {
READ_ADDR(); printf("ASL $%04X\n", READ_U16());
printf("ASL $%04X\n", addr);
} break; } break;
case 0x10: { case 0x10: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BPL $%04X\n", m->pc + offset); printf("BPL $%04X\n", m->pc + offset);
} break; } break;
case 0x11: { case 0x11: {
printf("ORA ($%02X),Y\n", m->memory[m->pc++]); printf("ORA ($%02X),Y\n", READ_U8());
} break; } break;
case 0x15: { case 0x15: {
printf("ORA $%02X,X\n", m->memory[m->pc++]); printf("ORA $%02X,X\n", READ_U8());
} break; } break;
case 0x16: { case 0x16: {
printf("ASL $%02X,X\n", m->memory[m->pc++]); printf("ASL $%02X,X\n", READ_U8());
} break; } break;
case 0x18: { case 0x18: {
printf("CLC\n"); printf("CLC\n");
} break; } break;
case 0x19: { case 0x19: {
READ_ADDR(); printf("ORA $%04X,Y\n", READ_U16());
printf("ORA $%04X,Y\n", addr);
} break; } break;
case 0x1D: { case 0x1D: {
READ_ADDR(); printf("ORA $%04X,X\n", READ_U16());
printf("ORA $%04X,X\n", addr);
} break; } break;
case 0x1E: { case 0x1E: {
READ_ADDR(); printf("ASL $%04X,X\n", READ_U16());
printf("ASL $%04X,X\n", addr);
} break; } break;
case 0x20: { case 0x20: {
READ_ADDR(); printf("JSR $%04X\n", READ_U16());
printf("JSR $%04X\n", addr);
} break; } break;
case 0x21: { case 0x21: {
printf("AND ($%02X,X)\n", m->memory[m->pc++]); printf("AND ($%02X,X)\n", READ_U8());
} break; } break;
case 0x24: { case 0x24: {
printf("BIT $%02X\n", m->memory[m->pc++]); printf("BIT $%02X\n", READ_U8());
} break; } break;
case 0x25: { case 0x25: {
printf("AND $%02X\n", m->memory[m->pc++]); printf("AND $%02X\n", READ_U8());
} break; } break;
case 0x26: { case 0x26: {
printf("ROL $%02X\n", m->memory[m->pc++]); printf("ROL $%02X\n", READ_U8());
} break; } break;
case 0x28: { case 0x28: {
printf("PLP\n"); printf("PLP\n");
} break; } break;
case 0x29: { case 0x29: {
printf("AND #$%02X\n", m->memory[m->pc++]); printf("AND #$%02X\n", READ_U8());
} break; } break;
case 0x2A: { case 0x2A: {
printf("ROL A\n"); printf("ROL A\n");
} break; } break;
case 0x2C: { case 0x2C: {
READ_ADDR(); printf("BIT $%04X\n", READ_U16());
printf("BIT $%04X\n", addr);
} break; } break;
case 0x2D: { case 0x2D: {
READ_ADDR(); printf("AND $%04X\n", READ_U16());
printf("AND $%04X\n", addr);
} break; } break;
case 0x2E: { case 0x2E: {
READ_ADDR(); printf("ROL $%04X\n", READ_U16());
printf("ROL $%04X\n", addr);
} break; } break;
case 0x30: { case 0x30: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BMI $%04X\n", m->pc + offset); printf("BMI $%04X\n", m->pc + offset);
} break; } break;
case 0x31: { case 0x31: {
printf("AND ($%02X),Y\n", m->memory[m->pc++]); printf("AND ($%02X),Y\n", READ_U8());
} break; } break;
case 0x35: { case 0x35: {
printf("AND $%02X,X\n", m->memory[m->pc++]); printf("AND $%02X,X\n", READ_U8());
} break; } break;
case 0x36: { case 0x36: {
printf("ROL $%02X,X\n", m->memory[m->pc++]); printf("ROL $%02X,X\n", READ_U8());
} break; } break;
case 0x38: { case 0x38: {
printf("SEC\n"); printf("SEC\n");
} break; } break;
case 0x39: { case 0x39: {
READ_ADDR(); printf("AND $%04X,Y\n", READ_U16());
printf("AND $%04X,Y\n", addr);
} break; } break;
case 0x3D: { case 0x3D: {
READ_ADDR(); printf("AND $%04X,X\n", READ_U16());
printf("AND $%04X,X\n", addr);
} break; } break;
case 0x3E: { case 0x3E: {
READ_ADDR(); printf("ROL $%04X,X\n", READ_U16());
printf("ROL $%04X,X\n", addr);
} break; } break;
case 0x40: { case 0x40: {
printf("RTI\n"); printf("RTI\n");
} break; } break;
case 0x41: { case 0x41: {
printf("EOR ($%02X,X)\n", m->memory[m->pc++]); printf("EOR ($%02X,X)\n", READ_U8());
} break; } break;
case 0x45: { case 0x45: {
printf("EOR $%02X\n", m->memory[m->pc++]); printf("EOR $%02X\n", READ_U8());
} break; } break;
case 0x46: { case 0x46: {
printf("LSR $%02X\n", m->memory[m->pc++]); printf("LSR $%02X\n", READ_U8());
} break; } break;
case 0x48: { case 0x48: {
printf("PHA\n"); printf("PHA\n");
} break; } break;
case 0x49: { case 0x49: {
printf("EOR #$%02X\n", m->memory[m->pc++]); printf("EOR #$%02X\n", READ_U8());
} break; } break;
case 0x4A: { case 0x4A: {
printf("LSR A\n"); printf("LSR A\n");
} break; } break;
case 0x4C: { case 0x4C: {
READ_ADDR(); printf("JMP $%04X\n", READ_U16());
printf("JMP $%04X\n", addr);
} break; } break;
case 0x4D: { case 0x4D: {
READ_ADDR(); printf("EOR $%04X\n", READ_U16());
printf("EOR $%04X\n", addr);
} break; } break;
case 0x4E: { case 0x4E: {
READ_ADDR(); printf("LSR $%04X\n", READ_U16());
printf("LSR $%04X\n", addr);
} break; } break;
case 0x50: { case 0x50: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BVC $%04X\n", m->pc + offset); printf("BVC $%04X\n", m->pc + offset);
} break; } break;
case 0x51: { case 0x51: {
printf("EOR ($%02X),Y\n", m->memory[m->pc++]); printf("EOR ($%02X),Y\n", READ_U8());
} break; } break;
case 0x55: { case 0x55: {
printf("EOR $%02X,X\n", m->memory[m->pc++]); printf("EOR $%02X,X\n", READ_U8());
} break; } break;
case 0x56: { case 0x56: {
printf("LSR $%02X,X\n", m->memory[m->pc++]); printf("LSR $%02X,X\n", READ_U8());
} break; } break;
case 0x58: { case 0x58: {
printf("CLI\n"); printf("CLI\n");
} break; } break;
case 0x59: { case 0x59: {
READ_ADDR(); printf("EOR $%04X,Y\n", READ_U16());
printf("EOR $%04X,Y\n", addr);
} break; } break;
case 0x5D: { case 0x5D: {
READ_ADDR(); printf("EOR $%04X,X\n", READ_U16());
printf("EOR $%04X,X\n", addr);
} break; } break;
case 0x5E: { case 0x5E: {
READ_ADDR(); printf("LSR $%04X,X\n", READ_U16());
printf("LSR $%04X,X\n", addr);
} break; } break;
case 0x60: { case 0x60: {
printf("RTS\n"); printf("RTS\n");
} break; } break;
case 0x61: { case 0x61: {
printf("ADC ($%02X,X)\n", m->memory[m->pc++]); printf("ADC ($%02X,X)\n", READ_U8());
} break; } break;
case 0x65: { case 0x65: {
printf("ADC $%02X\n", m->memory[m->pc++]); printf("ADC $%02X\n", READ_U8());
} break; } break;
case 0x66: { case 0x66: {
printf("ROR $%02X\n", m->memory[m->pc++]); printf("ROR $%02X\n", READ_U8());
} break; } break;
case 0x68: { case 0x68: {
printf("PLA\n"); printf("PLA\n");
} break; } break;
case 0x69: { case 0x69: {
printf("ADC #$%02X\n", m->memory[m->pc++]); printf("ADC #$%02X\n", READ_U8());
} break; } break;
case 0x6A: { case 0x6A: {
printf("ROR A\n"); printf("ROR A\n");
} break; } break;
case 0x6C: { case 0x6C: {
READ_ADDR(); printf("JMP ($%04X)\n", READ_U16());
printf("JMP ($%04X)\n", addr);
} break; } break;
case 0x6D: { case 0x6D: {
READ_ADDR(); printf("ADC $%04X\n", READ_U16());
printf("ADC $%04X\n", addr);
} break; } break;
case 0x6E: { case 0x6E: {
READ_ADDR(); printf("ROR $%04X\n", READ_U16());
printf("ROR $%04X\n", addr);
} break; } break;
case 0x70: { case 0x70: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BVS $%04X\n", m->pc + offset); printf("BVS $%04X\n", m->pc + offset);
} break; } break;
case 0x71: { case 0x71: {
printf("ADC ($%02X),Y\n", m->memory[m->pc++]); printf("ADC ($%02X),Y\n", READ_U8());
} break; } break;
case 0x75: { case 0x75: {
printf("ADC $%02X,X\n", m->memory[m->pc++]); printf("ADC $%02X,X\n", READ_U8());
} break; } break;
case 0x76: { case 0x76: {
printf("ROR $%02X,X\n", m->memory[m->pc++]); printf("ROR $%02X,X\n", READ_U8());
} break; } break;
case 0x78: { case 0x78: {
printf("SEI\n"); printf("SEI\n");
} break; } break;
case 0x79: { case 0x79: {
READ_ADDR(); printf("ADC $%04X,Y\n", READ_U16());
printf("ADC $%04X,Y\n", addr);
} break;
case 0x7E: {
READ_ADDR();
printf("ROR $%04X,X\n", addr);
} break; } break;
case 0x7D: { case 0x7D: {
READ_ADDR(); printf("ADC $%04X,X\n", READ_U16());
printf("ADC $%04X,X\n", addr); } break;
case 0x7E: {
printf("ROR $%04X,X\n", READ_U16());
} break; } break;
case 0x81: { case 0x81: {
printf("STA ($%02X,X)\n", m->memory[m->pc++]); printf("STA ($%02X,X)\n", READ_U8());
} break; } break;
case 0x84: { case 0x84: {
printf("STY $%02X\n", m->memory[m->pc++]); printf("STY $%02X\n", READ_U8());
} break; } break;
case 0x85: { case 0x85: {
printf("STA $%02X\n", m->memory[m->pc++]); printf("STA $%02X\n", READ_U8());
} break; } break;
case 0x86: { case 0x86: {
printf("STX $%02X\n", m->memory[m->pc++]); printf("STX $%02X\n", READ_U8());
} break; } break;
case 0x88: { case 0x88: {
printf("DEY\n"); printf("DEY\n");
@@ -296,255 +270,230 @@ void mos6502_disassemble(MOS6502 *m, size_t program_size) {
printf("TXA\n"); printf("TXA\n");
} break; } break;
case 0x8C: { case 0x8C: {
READ_ADDR(); printf("STY $%04X\n", READ_U16());
printf("STY $%04X\n", addr);
} break; } break;
case 0x8D: { case 0x8D: {
READ_ADDR(); printf("STA $%04X\n", READ_U16());
printf("STA $%04X\n", addr);
} break; } break;
case 0x8E: { case 0x8E: {
READ_ADDR(); printf("STX $%04X\n", READ_U16());
printf("STX $%04X\n", addr);
} break; } break;
case 0x90: { case 0x90: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BCC $%04X\n", m->pc + offset); printf("BCC $%04X\n", m->pc + offset);
} break; } break;
case 0x91: { case 0x91: {
printf("STA ($%02X),Y\n", m->memory[m->pc++]); printf("STA ($%02X),Y\n", READ_U8());
} break; } break;
case 0x94: { case 0x94: {
printf("STY $%02X,X\n", m->memory[m->pc++]); printf("STY $%02X,X\n", READ_U8());
} break; } break;
case 0x95: { case 0x95: {
printf("STA $%02X,X\n", m->memory[m->pc++]); printf("STA $%02X,X\n", READ_U8());
} break; } break;
case 0x96: { case 0x96: {
printf("STX $%02X,Y\n", m->memory[m->pc++]); printf("STX $%02X,Y\n", READ_U8());
} break; } break;
case 0x98: { case 0x98: {
printf("TYA\n"); printf("TYA\n");
} break; } break;
case 0x99: { case 0x99: {
READ_ADDR(); printf("STA $%04X,Y\n", READ_U16());
printf("STA $%04X,Y\n", addr);
} break; } break;
case 0x9A: { case 0x9A: {
printf("TXS\n"); printf("TXS\n");
} break; } break;
case 0x9D: { case 0x9D: {
READ_ADDR(); printf("STA $%04X,X\n", READ_U16());
printf("STA $%04X,X\n", addr);
} break; } break;
case 0xA0: { case 0xA0: {
printf("LDY #$%02X\n", m->memory[m->pc++]); printf("LDY #$%02X\n", READ_U8());
} break; } break;
case 0xA1: { case 0xA1: {
printf("LDA ($%02X,X)\n", m->memory[m->pc++]); printf("LDA ($%02X,X)\n", READ_U8());
} break; } break;
case 0xA2: { case 0xA2: {
printf("LDX #$%02X\n", m->memory[m->pc++]); printf("LDX #$%02X\n", READ_U8());
} break; } break;
case 0xA4: { case 0xA4: {
printf("LDY $%02X\n", m->memory[m->pc++]); printf("LDY $%02X\n", READ_U8());
} break; } break;
case 0xA5: { case 0xA5: {
printf("LDA $%02X\n", m->memory[m->pc++]); printf("LDA $%02X\n", READ_U8());
} break; } break;
case 0xA6: { case 0xA6: {
printf("LDX $%02X\n", m->memory[m->pc++]); printf("LDX $%02X\n", READ_U8());
} break; } break;
case 0xA8: { case 0xA8: {
printf("TAY\n"); printf("TAY\n");
} break; } break;
case 0xA9: { case 0xA9: {
printf("LDA #$%02X\n", m->memory[m->pc++]); printf("LDA #$%02X\n", READ_U8());
} break; } break;
case 0xAA: { case 0xAA: {
printf("TAX\n"); printf("TAX\n");
} break; } break;
case 0xAC: { case 0xAC: {
READ_ADDR(); printf("LDY $%04X\n", READ_U16());
printf("LDY $%04X\n", addr);
} break; } break;
case 0xAD: { case 0xAD: {
READ_ADDR(); printf("LDA $%04X\n", READ_U16());
printf("LDA $%04X\n", addr);
} break; } break;
case 0xAE: { case 0xAE: {
READ_ADDR(); printf("LDX $%04X\n", READ_U16());
printf("LDX $%04X\n", addr);
} break; } break;
case 0xB0: { case 0xB0: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BCS $%04X\n", m->pc + offset); printf("BCS $%04X\n", m->pc + offset);
} break; } break;
case 0xB1: { case 0xB1: {
printf("LDA ($%02X,Y)\n", m->memory[m->pc++]); printf("LDA ($%02X),Y\n", READ_U8());
} break; } break;
case 0xB4: { case 0xB4: {
printf("LDY $%02X,X\n", m->memory[m->pc++]); printf("LDY $%02X,X\n", READ_U8());
} break; } break;
case 0xB5: { case 0xB5: {
printf("LDA $%02X,X\n", m->memory[m->pc++]); printf("LDA $%02X,X\n", READ_U8());
} break; } break;
case 0xB6: { case 0xB6: {
printf("LDX $%02X,Y\n", m->memory[m->pc++]); printf("LDX $%02X,Y\n", READ_U8());
} break; } break;
case 0xB8: { case 0xB8: {
printf("CLV\n"); printf("CLV\n");
} break; } break;
case 0xB9: { case 0xB9: {
READ_ADDR(); printf("LDA $%04X,Y\n", READ_U16());
printf("LDA $%04X,Y\n", addr);
} break; } break;
case 0xBA: { case 0xBA: {
printf("TSX\n"); printf("TSX\n");
} break; } break;
case 0xBC: { case 0xBC: {
READ_ADDR(); printf("LDY $%04X,X\n", READ_U16());
printf("LDY $%04X,X\n", addr);
} break; } break;
case 0xBD: { case 0xBD: {
READ_ADDR(); printf("LDA $%04X,X\n", READ_U16());
printf("LDA $%04X,X\n", addr);
} break; } break;
case 0xBE: { case 0xBE: {
READ_ADDR(); printf("LDX $%04X,Y\n", READ_U16());
printf("LDX $%04X,Y\n", addr);
} break; } break;
case 0xC0: { case 0xC0: {
printf("CPY #$%02X\n", m->memory[m->pc++]); printf("CPY #$%02X\n", READ_U8());
} break; } break;
case 0xC1: { case 0xC1: {
printf("CMP ($%02X,X)\n", m->memory[m->pc++]); printf("CMP ($%02X,X)\n", READ_U8());
} break; } break;
case 0xC4: { case 0xC4: {
printf("CPY $%02X\n", m->memory[m->pc++]); printf("CPY $%02X\n", READ_U8());
} break; } break;
case 0xC5: { case 0xC5: {
printf("CMP $%02X\n", m->memory[m->pc++]); printf("CMP $%02X\n", READ_U8());
} break; } break;
case 0xC6: { case 0xC6: {
printf("DEC $%02X\n", m->memory[m->pc++]); printf("DEC $%02X\n", READ_U8());
} break; } break;
case 0xC8: { case 0xC8: {
printf("INY\n"); printf("INY\n");
} break; } break;
case 0xC9: { case 0xC9: {
printf("CMP #$%02X\n", m->memory[m->pc++]); printf("CMP #$%02X\n", READ_U8());
} break; } break;
case 0xCA: { case 0xCA: {
printf("DEX\n"); printf("DEX\n");
} break; } break;
case 0xCC: { case 0xCC: {
READ_ADDR(); printf("CPY $%04X\n", READ_U16());
printf("CPY $%04X\n", addr);
} break; } break;
case 0xCD: { case 0xCD: {
READ_ADDR(); printf("CMP $%04X\n", READ_U16());
printf("CMP $%04X\n", addr);
} break; } break;
case 0xCE: { case 0xCE: {
READ_ADDR(); printf("DEC $%04X\n", READ_U16());
printf("DEC $%04X\n", addr);
} break; } break;
case 0xD0: { case 0xD0: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BNE $%04X\n", m->pc + offset); printf("BNE $%04X\n", m->pc + offset);
} break; } break;
case 0xD1: { case 0xD1: {
printf("CMP ($%02X),Y\n", m->memory[m->pc++]); printf("CMP ($%02X),Y\n", READ_U8());
} break; } break;
case 0xD5: { case 0xD5: {
printf("CMP $%02X,X\n", m->memory[m->pc++]); printf("CMP $%02X,X\n", READ_U8());
} break; } break;
case 0xD6: { case 0xD6: {
printf("DEC $%02X,X\n", m->memory[m->pc++]); printf("DEC $%02X,X\n", READ_U8());
} break; } break;
case 0xD8: { case 0xD8: {
printf("CLD\n"); printf("CLD\n");
} break; } break;
case 0xD9: { case 0xD9: {
READ_ADDR(); printf("CMP $%04X,Y\n", READ_U16());
printf("CMP $%04X,Y\n", addr);
} break; } break;
case 0xDD: { case 0xDD: {
READ_ADDR(); printf("CMP $%04X,X\n", READ_U16());
printf("CMP $%04X,X\n", addr);
} break; } break;
case 0xDE: { case 0xDE: {
READ_ADDR(); printf("DEC $%04X,X\n", READ_U16());
printf("DEC $%04X,X\n", addr);
} break; } break;
case 0xE0: { case 0xE0: {
printf("CPX #$%02X\n", m->memory[m->pc++]); printf("CPX #$%02X\n", READ_U8());
} break; } break;
case 0xE1: { case 0xE1: {
printf("SBC ($%02X,X)\n", m->memory[m->pc++]); printf("SBC ($%02X,X)\n", READ_U8());
} break; } break;
case 0xE4: { case 0xE4: {
printf("CPX $%02X\n", m->memory[m->pc++]); printf("CPX $%02X\n", READ_U8());
} break; } break;
case 0xE5: { case 0xE5: {
printf("SBC $%02X\n", m->memory[m->pc++]); printf("SBC $%02X\n", READ_U8());
} break; } break;
case 0xE6: { case 0xE6: {
printf("INC $%02X\n", m->memory[m->pc++]); printf("INC $%02X\n", READ_U8());
} break; } break;
case 0xE8: { case 0xE8: {
printf("INX\n"); printf("INX\n");
} break; } break;
case 0xE9: { case 0xE9: {
printf("SBC #$%02X\n", m->memory[m->pc++]); printf("SBC #$%02X\n", READ_U8());
} break; } break;
case 0xEA: { case 0xEA: {
printf("NOP\n"); printf("NOP\n");
} break; } break;
case 0xEC: { case 0xEC: {
READ_ADDR(); printf("CPX $%04X\n", READ_U16());
printf("CPX $%04X\n", addr);
} break; } break;
case 0xED: { case 0xED: {
READ_ADDR(); printf("SBC $%04X\n", READ_U16());
printf("SBC $%04X\n", addr);
} break; } break;
case 0xEE: { case 0xEE: {
READ_ADDR(); printf("INC $%04X\n", READ_U16());
printf("INC $%04X\n", addr);
} break; } break;
case 0xF0: { case 0xF0: {
int8_t offset = m->memory[m->pc++]; int8_t offset = READ_U8();
printf("BEQ $%04X\n", m->pc + offset); printf("BEQ $%04X\n", m->pc + offset);
} break; } break;
case 0xF1: { case 0xF1: {
printf("SBC ($%02X),Y\n", m->memory[m->pc++]); printf("SBC ($%02X),Y\n", READ_U8());
} break; } break;
case 0xF5: { case 0xF5: {
printf("SBC $%02X,X\n", m->memory[m->pc++]); printf("SBC $%02X,X\n", READ_U8());
} break; } break;
case 0xF6: { case 0xF6: {
printf("INC $%02X,X\n", m->memory[m->pc++]); printf("INC $%02X,X\n", READ_U8());
} break; } break;
case 0xF8: { case 0xF8: {
printf("SED\n"); printf("SED\n");
} break; } break;
case 0xF9: { case 0xF9: {
READ_ADDR(); printf("SBC $%04X,Y\n", READ_U16());
printf("SBC $%04X,Y\n", addr);
} break; } break;
case 0xFD: { case 0xFD: {
READ_ADDR(); printf("SBC $%04X,X\n", READ_U16());
printf("SBC $%04X,X\n", addr);
} break; } break;
case 0xFE: { case 0xFE: {
READ_ADDR(); printf("INC $%04X,X\n", READ_U16());
printf("INC $%04X,X\n", addr);
} break; } break;
default: default:
fprintf(stderr, "unrecognized opcode: %02X\n", op); printf("???\n");
exit(1);
} }
} }
} }