#define DEBUG 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
//#define SAMESEX 1
// Host processor has same byte sex as target - we can optimise some
// cases with shorts rather than two single byte accesses
// but for portability, get the single-byte cases working first...
#ifndef FALSE
#define FALSE (0!=0)
#define TRUE (0==0)
#endif
#define MAX 10240
long defs[MAX], uses[MAX];
char *codes[MAX];
int nextfree = 0;
/* Metacodes */
#define Always 1
#define Flush 2
// #define R_P 4
// - in this emulator we affect only individual bits
// (this may change as we make some efficiency tweaks)
#define R_A 8
#define R_X 16
#define R_Y 32
#define R_PC 64
#define R_S 128
/* Internal emulator variables */
#define R_VALUE 256
#define R_CLOCKTICKS 512
#define R_TEMP 1024
/* Specific bits in the condition-code register. Treat
them as if they were independant variables. */
#define R_P_Z 2048 /* zero */
#define R_P_N 4096 /* negative */
#define R_P_C 8192 /* carry */
#define R_P_D 16384 /* binary-coded decimal mode */
#define R_P_V 32768 /* overflow */
#define R_P (R_P_Z|R_P_N|R_P_C|R_P_D|R_P_V)
#define R_SAVEFLAGS 65536 /* overflow */
#define R_FLUSH (Always|R_CLOCKTICKS|R_S|R_PC|R_Y|R_X|R_A|R_P_Z|R_P_N|R_P_C|R_P_D|R_P_V)
static int clockticks = 0, cond_clockticks = 0;
void unconditional_clockticks (int ticks) {
clockticks += ticks;
}
/* conditional_clockticks would do a dumpf to set clockticks equal
to the sum of clockticks plus the parameter but doesn't update
clockticks itself. For use in conditional branches. "To do..." */
void conditional_clockticks (int ticks) {
/*** TO DO !!! ***/
cond_clockticks += ticks;
}
void flush (long regs) {
int i;
long common_regs;
for (i = nextfree - 1; i >= 0; --i) {
if (common_regs = (regs & defs[i])) {
/* if bits in 'defs' then this needs to be dumped. */
// fprintf(stdout, "// %02d lookfor: %02x Item %d - def %02x\n",
// nextfree, regs, i, defs[i]);
defs[i] |= Always; /* flag this line for printing */
regs &= ~common_regs; /* don't need to look for these ones any more */
}
if (defs[i] & Always)
regs |= uses[i]; /* Any unconditionals + parents */
}
for (i = 0; i < nextfree; i++) {
if (DEBUG) { fprintf (stdout, "/* %03d [def:%04lx] [use:%04lx] */", i, defs[i], uses[i]); }
fprintf (stdout, " %s %s", (defs[i] & Always ? " " : "// "), codes[i]);
/* should free strings here... */
}
}
void unconditional_flush (char *inst) {
flush (R_FLUSH);
if (DEBUG) { fprintf (stdout, "/* */"); }
fprintf (stdout, " clockticks += %d; /*poll_nmi(opadd);*/\n", clockticks);
clockticks = 0;
cond_clockticks = 0;
if (DEBUG) { printf ("/* */"); }
printf (" %s\n", inst);
nextfree = 0;
}
void conditional_flush (char *inst) {
/* TO DO!!! This is tricky... */
flush (R_FLUSH);
if (DEBUG) { fprintf (stdout, "/* */"); }
fprintf (stdout, " clockticks += %d;\n", clockticks + cond_clockticks);
if (DEBUG) { fprintf (stdout, "/* */"); }
fprintf (stdout, " poll_nmi(opadd); /* if (...) return to dispatch loop - PC is address of NMI proc - real PC is on stack */\n");
cond_clockticks = 0;
if (DEBUG) { printf ("/* */"); }
printf (" %s\n", inst);
nextfree = 0;
}
void dumpf (int def, int use, char *s, ...) { /* Works like printf */
static FILE *nullfile = NULL;
static char *buff = NULL;
static int bufflen = 0;
va_list ap;
if (nullfile == NULL) {
nullfile = fopen ("/dev/null", "w");
if (nullfile == NULL) {
fprintf (stderr, "Major error - cannot open /dev/null\n");
exit (1);
}
}
if (buff == NULL) {
buff = malloc (bufflen = 256);
if (buff == NULL) exit (2); // if malloc failed so will printf!
}
va_start (ap, s);
{
int string_length;
string_length = vfprintf (nullfile, s, ap);
if (string_length + 1 >= bufflen) {
free (buff);
buff = malloc (bufflen = 2 * string_length);
if (buff == NULL)
exit (3);
}
vsprintf (buff, s, ap);
}
va_end (ap);
defs[nextfree] = def;
uses[nextfree] = use;
codes[nextfree] = strdup (buff);
nextfree += 1;
// fprintf(stderr, "// %s", buff);
}
FILE *fp;
unsigned short sa;
unsigned short temp;
unsigned short temp2;
unsigned char rom[0x8000];
unsigned char hitlist[0x8000];
unsigned char newline[1024];
void tempword (unsigned short opadd) {
temp = rom[opadd + 2];
temp <<= 8;
temp |= rom[opadd + 1];
// Originally had this line:
// temp &= 0x7FFF;
// I assume that was a mistake and it should be this???
temp &= 0xFFFF;
// if indeed the mask is even necessary at all???
}
void translate (unsigned short opadd, unsigned char opcode) {
switch (opcode) {
case 0x00: // [brk_implied]
// static void brk_implied () // 0x00
// {
// PC++;
// put6502memory(0x0100+S--,PC >> 8);
// put6502memory(0x0100+S--,PC & 0xff);
// put6502memory(0x0100+S--,P);
// P |= 0x14;
// PC=get6502memory(0xfffe);
// PC |= get6502memory(0xffff) << 8;
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
return;
case 0x01: // [ora_indx]
// static void ora_indx () // 0x01
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
/* Cannot use ZN as a temp, it is a signed char */
dumpf (Always | R_VALUE, Always | R_X, " temp = ram[(unsigned short)(0x%04X + X)]<<8;\n", temp + 1);
dumpf (Always | R_VALUE, Always | R_VALUE | R_X, " temp |= ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_A | Always, Always | R_A | R_VALUE, " A |= ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x02: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x03: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x04: // [tsb_zp]
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
#ifdef NEVER
// static void tsb_zp () // 0x04
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// value |= A;
// DO_Z (value);
// put6502memory(savepc,value);
//
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X TSB ??? non-standard opcode?\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE | Always, R_A | Always, " ZN=ram[0x%04X] | A;\n", temp);
dumpf (R_P_Z, R_VALUE, " DO_Z (ZN); /* This doesn't set N as well?? */\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
#endif
return;
case 0x05: // [ora_zp]
// static void ora_zp () // 0x05
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_A | Always, R_A | Always, " A|=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x06: // [asl_zp]
// static void asl_zp () // 0x06
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 5;
// }
// Doesn't affect carry??? (If it does, this is buggy)
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x80; /* We're stealing ZN for use as a temp */\n");
dumpf (R_P_Z | R_P_N, R_VALUE, " ZN = ZN << 1;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_P_Z | R_P_N, " ram[0x%04X] = ZN; /* Because at this point it actually has the correct value in it */\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x07: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x08: // [php_implied]
// static void php_implied () // 0x08
// {
// put6502memory(0x100+S--,P);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
dumpf (Always | R_S, Always | R_P | R_P_C | R_P_Z | R_P_N | R_S, " stack[S--] = P; // todo: consolidate ZN, C\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x09: // [ora_immediate]
// static void ora_immediate () // 0x09
// {
// savepc=PC++;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " A |= 0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0A: // [asla_implied]
// static void asla_implied () // 0x0a
// {
// P= (P & 0xfe) | ((A >> 7) & 0x01);
// A = A << 1;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_P_C, R_A, " C = A & 0x80;\n");
dumpf (R_A, R_A, " A = A << 1;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0C: // [tsb_abs]
// static void tsb_abs () // 0x0c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// value |= A;
// DO_Z (value);
// put6502memory(savepc,value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_VALUE, R_VALUE | R_A, " ZN |= A;\n");
dumpf (R_P_Z, R_VALUE, " DO_Z (ZN);\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0D: // [ora_abs]
// static void ora_abs () // 0x0d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " A|=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0E: // [asl_abs]
// static void asl_abs () // 0x0e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x80;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN << 1;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x0F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x10: // [bpl_relative]
// static void bpl_relative () // 0x10
// {
// if ((P & 0x80)==0)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always | R_P_N, " if (ZN < 0)\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x11: // [ora_indy]
// static void ora_indy () // 0x11
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=0x%02X+Y;\n", temp);
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x12: // [ora_indzp]
// static void ora_indzp () // 0x12
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x13: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x14: // [trb_zp]
// static void trb_zp () // 0x14
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// value &= (A ^ 0xff);
// DO_Z (value);
// put6502memory(savepc,value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x15: // [ora_zpx]
// static void ora_zpx () // 0x15
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " A |= ZN;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x16: // [asl_zpx]
// static void asl_zpx () // 0x16
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x17: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x18: // [clc_implied]
// static void clc_implied () // 0x18
// {
// P &= 0xfe;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_P_C, 0, " C = 0;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x19: // [ora_absy]
// static void ora_absy () // 0x19
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_Y | Always, " ZN=ram[(unsigned short)(0x%04X + Y)];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x1A: // [ina_implied]
// static void ina_implied () // 0x1a
// {
// A++;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x1B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x1C: // [trb_abs]
// static void trb_abs () // 0x1c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// value &= (A ^ 0xff);
// DO_Z (value);
// put6502memory(savepc,value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x1D: // [ora_absx]
// static void ora_absx () // 0x1d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// value=get6502memory(savepc);
// A |= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_X | Always, " A |= ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x1E: // [asl_absx]
// static void asl_absx () // 0x1e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (Always, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x1F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x20: // [jsr_abs]
// static void jsr_abs () // 0x20
// {
// PC++;
// put6502memory(0x0100+S--,PC >> 8);
// put6502memory(0x0100+S--,PC & 0xff);
// PC--;
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// PC=savepc;
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
temp2 = opadd + 2;
dumpf (Always, Always, " stack[S--] = 0x%02X;\n", (temp2 >> 8) & 0x7F);
dumpf (Always, Always, " stack[S--] = 0x%02X;\n", temp2 & 0xFF);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", temp);
unconditional_flush ("return;\n");
return;
case 0x21: // [and_indx]
// static void and_indx () // 0x21
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp+=X;\n");
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x22: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x23: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x24: // [bit_zp]
// static void bit_zp () // 0x24
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// DO_Z (value & A);
// P = (P & 0x3f) | (value & 0xc0);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
// Bits Data:7 and Data:6 are transferred to P:N and P:V respectively
// P:Z is set to 1 iff Data&A==0
dumpf (R_VALUE | R_P_N | Always, Always, " ZN=ram[0x%04X]; // N is correct, Z is not. Asteroids never tests Z after a Bit instruction...\n", temp);
dumpf (R_P_Z, R_VALUE | R_A, " // DO_Z (ZN & A); // *** Not compatible with our ZN hack!\n");
// P & 0x40 is the V flag
dumpf (R_P_V, R_VALUE, " P = (P & 0xbf) | (ZN & 0x40); // Set V\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x25: // [and_zp]
// static void and_zp () // 0x25
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_A, Always | R_A, " A &= ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x26: // [rol_zp]
// static void rol_zp () // 0x26
// {
// int saveflags=(P & 0x01);
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// value |= saveflags;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_SAVEFLAGS, R_P_C, " saveflags=(C != 0 ? 1 : 0);\n");
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
/* 'ZN' is really 'value'; just saving a register... */
dumpf (R_P_C, R_VALUE, " C = ZN & 0x80;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN << 1;\n");
dumpf (R_P_Z | R_P_N, R_VALUE | R_SAVEFLAGS, " ZN |= saveflags;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_P_Z | R_P_N, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x27: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x28: // [plp_implied]
// static void plp_implied () // 0x28
// {
// P=get6502memory(++S+0x100);
// P |= 0x20;
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
dumpf (Always | R_P | R_S | R_P_C | R_P_Z | R_P_N, Always | R_S, " P=stack[++S]; // todo: set C, ZN\n");
dumpf (R_P, R_P, " P |= 0x20; /* PLP - needs work */\n"); // which bit is that?
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x29: // [and_immediate]
// static void and_immediate () // 0x29
// {
// savepc=PC++;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_A, R_A, " A &= 0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x2A: // [rola_implied]
// static void rola_implied () // 0x2a
// {
// int saveflags=(P & 0x01);
// P= (P & 0xfe) | ((A >> 7) & 0x01);
// A = A << 1;
// A |= saveflags;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_SAVEFLAGS, R_P_C, " saveflags=(C != 0 ? 1 : 0);\n");
dumpf (R_P_C, R_A, " C = A & 0x80;\n");
dumpf (R_A, R_A, " A = A << 1;\n");
dumpf (R_A, R_A | R_SAVEFLAGS, " A |= saveflags;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x2B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x2C: // [bit_abs]
// static void bit_abs () // 0x2c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// DO_Z (value & A);
// P = (P & 0x3f) | (value & 0xc0);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
// Bits Data:7 and Data:6 are transferred to P:N and P:V respectively
// P:Z is set to 1 iff Data&A==0
dumpf (R_VALUE | R_P_N | Always, Always, " ZN=ram[0x%04X]; // N is correct, Z is not. Asteroids never tests Z after a Bit instruction...\n", temp);
dumpf (R_P_Z, R_VALUE | R_A, " // DO_Z (ZN & A); // *** Not compatible with our ZN hack!\n");
// P & 0x40 is the V flag
dumpf (R_P_V, R_VALUE, " P = (P & 0xbf) | (ZN & 0x40); // Set V\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x2D: // [and_abs]
// static void and_abs () // 0x2d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_A, Always | R_A, " A &= ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x2E: // [rol_abs]
// static void rol_abs () // 0x2e
// {
// int saveflags=(P & 0x01);
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// value |= saveflags;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
dumpf (Always | R_P_Z | R_P_N, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x2F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x30: // [bmi_relative]
// static void bmi_relative () // 0x30
// {
// if (P & 0x80)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always | R_P_N, " if(/*P*/ZN < 0 /*& 0x80*/)\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x31: // [and_indy]
// static void and_indy () // 0x31
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 5;
// }
// todo next
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " temp+=Y;\n");
dumpf (Always, Always, " A &= ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x32: // [and_indzp]
// static void and_indzp () // 0x32
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " A &= ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x33: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x34: // [bit_zpx]
// static void bit_zpx () // 0x34
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// DO_Z (value & A);
// P = (P & 0x3f) | (value & 0xc0);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
// Bits Data:7 and Data:6 are transferred to P:N and P:V respectively
// P:Z is set to 1 iff Data&A==0
dumpf (R_VALUE | R_P_N | Always, Always | R_X, " ZN=ram[(unsigned char)(0x%02X + X)]; // N is correct, Z is not. Asteroids never tests Z after a Bit instruction...\n",
temp);
dumpf (R_P_Z, R_VALUE | R_A, " // DO_Z (ZN & A); // *** Not compatible with our ZN hack!\n");
// P & 0x40 is the V flag
dumpf (R_P_V, R_VALUE, " P = (P & 0xbf) | (ZN & 0x40); // Set V\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x35: // [and_zpx]
// static void and_zpx () // 0x35
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " A &= ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x36: // [rol_zpx]
// static void rol_zpx () // 0x36
// {
// int saveflags=(P & 0x01);
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// value |= saveflags;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_SAVEFLAGS, R_P_C, " saveflags=(C != 0 ? 1 : 0);\n");
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (R_P_C, R_VALUE, " C = ZN & 0x80;\n");
dumpf (Always, Always, " ZN = ZN << 1;\n");
dumpf (R_VALUE, Always, " ZN |= saveflags;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_VALUE, " ram[temp] = ZN;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x37: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x38: // [sec_implied]
// static void sec_implied () // 0x38
// {
// P |= 0x01;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_P_C, 0, " C = 1;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x39: // [and_absy]
// static void and_absy () // 0x39
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_A, R_A | R_Y | Always, " A &= ram[(unsigned short)(0x%04X + Y)];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x3A: // [dea_implied]
// static void dea_implied () // 0x3a
// {
// A--;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_A, R_A, " A--;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x3B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x3C: // [bit_absx]
// static void bit_absx () // 0x3c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// value=get6502memory(savepc);
// DO_Z (value & A);
// P = (P & 0x3f) | (value & 0xc0);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
// Bits Data:7 and Data:6 are transferred to P:N and P:V respectively
// P:Z is set to 1 iff Data&A==0
dumpf (R_VALUE | R_P_N | Always, Always | R_X, " ZN=ram[(unsigned short)(0x%04X + X)]; // N is correct, Z is not. Asteroids never tests Z after a Bit instruction...\n",
temp);
dumpf (R_P_Z, R_VALUE | R_A, " // DO_Z (ZN & A); // *** Not compatible with our ZN hack!\n");
// P & 0x40 is the V flag
dumpf (R_P_V, R_VALUE, " P = (P & 0xbf) | (ZN & 0x40); // Set V\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x3D: // [and_absx]
// static void and_absx () // 0x3d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// value=get6502memory(savepc);
// A &= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_X | Always, " A &= ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x3E: // [rol_absx]
// static void rol_absx () // 0x3e
// {
// int saveflags=(P & 0x01);
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// P= (P & 0xfe) | ((value >> 7) & 0x01);
// value = value << 1;
// value |= saveflags;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = (C != 0 ? 1 : 0);\n");
dumpf (Always, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x80;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN << 1;\n");
dumpf (R_VALUE, Always, " ZN |= saveflags;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_X | R_VALUE, " ram[(unsigned short)(0x%04X + X)] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x3F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x40: // [rti_implied]
// static void rti_implied () // 0x40
// {
// P=get6502memory(++S+0x100);
// P |= 0x20;
// PC=get6502memory(++S+0x100);
// PC |= get6502memory(++S+0x100) << 8;
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
dumpf (Always, Always, " P = stack[++S] | 0x20; /* RTI - needs work */\n");
dumpf (Always, Always, " PC=stack[++S];\n");
dumpf (Always, Always, " PC|=((unsigned short)(stack[++S])<<8);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
// NOTE: We probably do not want to poll_nmi() before returning...
unconditional_flush ("return; /* Pop address where interrupt came from */\n");
return;
case 0x41: // [eor_indx]
// static void eor_indx () // 0x41
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp+=X;\n");
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x42: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x43: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x44: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x45: // [eor_zp]
// static void eor_zp () // 0x45
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " A^=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x46: // [lsr_zp]
// static void lsr_zp () // 0x46
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x47: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x48: // [pha_implied]
// static void pha_implied () // 0x48
// {
// put6502memory(0x100+S--,A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
dumpf (Always, Always, " stack[S--] = A;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x49: // [eor_immediate]
// static void eor_immediate () // 0x49
// {
// savepc=PC++;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_A, R_A, " A ^= 0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x4A: // [lsra_implied]
// static void lsra_implied () // 0x4a
// {
// P= (P & 0xfe) | (A & 0x01);
// A = A >> 1;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_P_C, R_A, " C = A & 0x01;\n");
dumpf (R_A, R_A, " A = A >> 1;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x4B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x4C: // [jmp_abs]
// static void jmp_abs () // 0x4c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// PC=savepc;
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
tempword (opadd);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", temp);
unconditional_flush ("return;\n");
return;
case 0x4D: // [eor_abs]
// static void eor_abs () // 0x4d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x4E: // [lsr_abs]
// static void lsr_abs () // 0x4e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
/* NO FLUSH */
return;
case 0x4F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x50: // [bvc_relative]
// static void bvc_relative () // 0x50
// {
// if ((P & 0x40)==0)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, R_P_V, " if ((P & 0x40) == 0) /* BVC */\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x51: // [eor_indy]
// static void eor_indy () // 0x51
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5); // TODO: add 1 if boundary crossed
temp = rom[opadd + 1];
#ifdef SAMESEX
dumpf (Always, Always | R_Y, " A ^= ram[(unsigned short)((*((unsigned short *)&ram[0x%04x]))+Y)]; /* Assume it won't wrap at 64K */\n", temp);
#else // other sex or sex unknown
dumpf (Always, Always | R_Y, " A ^= ram[(unsigned short)(((ram[0x%04X]<<8)|ram[0x%04x])+Y)]; /* Assume it won't wrap at 64K */\n", (temp + 1) & 0xffff, temp);
#endif
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x52: // [eor_indzp]
// static void eor_indzp () // 0x52
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x53: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x54: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x55: // [eor_zpx]
// static void eor_zpx () // 0x55
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " A ^= ZN;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x56: // [lsr_zpx]
// static void lsr_zpx () // 0x56
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x57: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x58: // [cli_implied]
// static void cli_implied () // 0x58
// {
// P &= 0xfb;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x59: // [eor_absy]
// static void eor_absy () // 0x59
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_Y | Always, " ZN=ram[(unsigned short)(0x%04X + Y)];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x5A: // [phy_implied]
// static void phy_implied () // 0x5a
// {
// put6502memory(0x100+S--,Y);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x5B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x5C: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x5D: // [eor_absx]
// static void eor_absx () // 0x5d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// value=get6502memory(savepc);
// A ^= value;
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (Always, Always, " A ^= ZN;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x5E: // [lsr_absx]
// static void lsr_absx () // 0x5e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (Always, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x5F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x60: // [rts_implied]
// static void rts_implied () // 0x60
// {
// PC=get6502memory(++S+0x100);
// PC |= get6502memory(++S+0x100) << 8;
// PC++;
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC=stack[++S];\n");
dumpf (Always, Always, " PC|=(unsigned short)(stack[++S])<<8;\n");
dumpf (Always, Always, " PC++; \n");
unconditional_flush ("return;\n");
return;
case 0x61: // [adc_indx]
// static void adc_indx () // 0x61
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// ADC (savepc);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp+=X;\n");
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x62: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x63: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x64: // [stz_zp]
// static void stz_zp () // 0x64
// {
// savepc=get6502memoryFast(PC++);
// put6502memory(savepc,0);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x65: // [adc_zp]
// static void adc_zp () // 0x65
// {
// savepc=get6502memoryFast(PC++);
// ADC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_P_C | R_P_D, " ADC(ram[0x%04X]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x66: // [ror_zp]
// static void ror_zp () // 0x66
// {
// int saveflags = (C != 0 ? 1 : 0);
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// if (saveflags) value |= 0x80;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = (C != 0 ? 1 : 0);\n");
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (R_VALUE, R_SAVEFLAGS | R_VALUE, " if (saveflags) ZN |= 0x80;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x67: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x68: // [pla_implied]
// static void pla_implied () // 0x68
// {
// A=get6502memory(++S+0x100);
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
dumpf (Always, Always, " A=stack[++S];\n");;
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x69: // [adc_immediate]
// static void adc_immediate () // 0x69
// {
// savepc=PC++;
// ADC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_P_C | R_P_D, " ADC(0x%02X);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x6A: // [rora_implied]
// static void rora_implied () // 0x6a
// {
// int saveflags = (C != 0 ? 1 : 0);
// P= (P & 0xfe) | (A & 0x01);
// A = A >> 1;
// if (saveflags) A |= 0x80;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = C;\n");
dumpf (R_P_C, R_A, " C = A & 0x01;\n");
dumpf (R_A, R_A, " A = A >> 1;\n");
dumpf (R_A, R_A | R_SAVEFLAGS, " if (saveflags) A |= 0x80;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x6B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x6C: // [jmp_indirect]
// static void jmp_indirect () // 0x6c
// {
// unsigned short help;
// help=get6502memoryFast(PC++);
// help |= get6502memoryFast(PC++) << 8;
// savepc=get6502memory(help++);
// savepc |= get6502memory(help) << 8;
// PC=savepc;
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x6D: // [adc_abs]
// static void adc_abs () // 0x6d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// ADC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_P_C | R_P_D, " ADC(ram[0x%04X]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x6E: // [ror_abs]
// static void ror_abs () // 0x6e
// {
// int saveflags = (C != 0 ? 1 : 0);
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// if (saveflags) value |= 0x80;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = C;\n");
dumpf (R_VALUE | Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (R_VALUE, R_SAVEFLAGS | R_VALUE, " if (saveflags) ZN |= 0x80;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, Always | R_VALUE, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x6F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x70: // [bvs_relative]
// static void bvs_relative () // 0x70
// {
// if (P & 0x40)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, R_P_V, " if (P & 0x40) /* BVS */\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x71: // [adc_indy]
// static void adc_indy () // 0x71
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// ADC (savepc);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " temp+=Y;\n");
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_P_C | R_P_D, " ADC(ram[temp]);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x72: // [adc_indzp]
// static void adc_indzp () // 0x72
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// ADC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_P_C | R_P_D, " ADC(ram[temp]);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x73: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x74: // [stz_zpx]
// static void stz_zpx () // 0x74
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// put6502memory(savepc,0);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ram[temp] = 0;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x75: // [adc_zpx]
// static void adc_zpx () // 0x75
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// ADC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always | R_A | R_P_Z | R_P_N | R_P_V | R_P_C, Always | R_A | R_P_C | R_P_D | R_X, " ADC(ram[(unsigned char)(0x%02X + X)]); /* zero page */\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x76: // [ror_zpx]
// static void ror_zpx () // 0x76
// {
// int saveflags = (C != 0 ? 1 : 0);
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// if (saveflags) value |= 0x80;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = C;\n");
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (R_VALUE | Always, Always, " ZN=ram[temp];\n");
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (R_VALUE, R_SAVEFLAGS | R_VALUE, " if (saveflags) ZN |= 0x80;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, Always, " ram[temp] = ZN;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x77: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x78: // [sei_implied]
// static void sei_implied () // 0x78
// {
// P |= 0x04;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " P |= 0x04;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x79: // [adc_absy]
// static void adc_absy () // 0x79
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// ADC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_P_Z | R_P_N | R_P_V | R_P_C, R_Y | Always | R_P_C | R_P_D, " ADC(ram[(unsigned short)(0x%04X + Y)]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x7A: // [ply_implied]
// static void ply_implied () // 0x7a
// {
// Y=get6502memory(++S+0x100);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
dumpf (Always, Always, " Y=stack[++S];\n");
dumpf (Always, Always, " DO_Z (Y);\n");
// dumpf(Always, Always, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x7B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x7C: // [jmp_indabsx]
// static void jmp_indabsx () // 0x7c
// {
// unsigned short help=get6502memoryFast(PC++);
// help |= get6502memoryFast(PC++) << 8;
// help += X;
// savepc=get6502memory(help++);
// savepc |= get6502memory(help) << 8;
// PC=savepc;
// clockticks += 6;
// }
tempword (opadd);
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0x7FFF;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC=ram[(unsigned short)(temp+1)];\n");
dumpf (Always, Always, " PC<<=8;\n");
dumpf (Always, Always, " PC|=ram[temp];\n");
unconditional_flush ("return;\n");
return;
case 0x7D: // [adc_absx]
// static void adc_absx () // 0x7d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// ADC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_A | R_P_Z | R_P_N | R_P_V | R_P_C, R_X | Always | R_A | R_P_C | R_P_D, " ADC(ram[(unsigned short)(0x%04X + X)]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x7E: // [ror_absx]
// static void ror_absx () // 0x7e
// {
// int saveflags = (C != 0 ? 1 : 0);
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// P= (P & 0xfe) | (value & 0x01);
// value = value >> 1;
// if (saveflags) value |= 0x80;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (R_SAVEFLAGS, R_P_C, " saveflags = C;\n");
dumpf (R_VALUE | Always, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_C, R_VALUE, " C = ZN & 0x01;\n");
dumpf (R_VALUE, R_VALUE, " ZN = ZN >> 1;\n");
dumpf (R_VALUE, R_SAVEFLAGS | R_VALUE, " if (saveflags) ZN |= 0x80;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_X | R_VALUE, " ram[(unsigned short)(0x%04X + X)] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x7F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x80: // [bra_relative]
// static void bra_relative () // 0x80
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
/* NO FLUSH */
return;
case 0x81: // [sta_indx]
// static void sta_indx () // 0x81
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// put6502memory(savepc,A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, R_X | Always, " temp|=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (Always, Always, " ram[temp] = A;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x82: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x83: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x84: // [sty_zp]
// static void sty_zp () // 0x84
// {
// savepc=get6502memoryFast(PC++);
// put6502memory(savepc,Y);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
dumpf (Always, R_Y, " ram[0x%04X] = Y;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x85: // [sta_zp]
// static void sta_zp () // 0x85
// {
// savepc=get6502memoryFast(PC++);
// put6502memory(savepc,A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
dumpf (Always, R_A, " ram[0x%04X] = A;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x86: // [stx_zp]
// static void stx_zp () // 0x86
// {
// savepc=get6502memoryFast(PC++);
// put6502memory(savepc,X);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
dumpf (Always, Always, " ram[0x%04X] = X;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x87: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x88: // [dey_implied]
// static void dey_implied () // 0x88
// {
// Y--;
// if (Y) P &= 0xfd; else P |= 0x02;
// if (Y & 0x80) P |= 0x80; else P &= 0x7f;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_Y, R_Y, " Y--;\n");
dumpf (R_P_Z | R_P_N, R_Y, " ZN = Y;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x89: // [bit_immediate]
// static void bit_immediate () // 0x89
// {
// savepc=PC++;
// value=get6502memory(savepc);
// DO_Z (value & A);
// P = (P & 0x3f) | (value & 0xc0);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
// Bits Data:7 and Data:6 are transferred to P:N and P:V respectively
// P:Z is set to 1 iff Data&A==0
dumpf (R_VALUE | R_P_N, 0, " ZN=0x%02X; // N is correct, Z is not. Asteroids never tests Z after a Bit instruction...\n", temp);
dumpf (R_P_Z, R_VALUE | R_A, " // DO_Z (ZN & A); // *** Not compatible with our ZN hack!\n");
// P & 0x40 is the V flag
dumpf (R_P_V, R_VALUE, " P = (P & 0xbf) | (ZN & 0x40); // Set V\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0x8A: // [txa_implied]
// static void txa_implied () // 0x8a
// {
// A=X;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " A=X;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x8B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x8C: // [sty_abs]
// static void sty_abs () // 0x8c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// put6502memory(savepc,Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " ram[0x%04X] = Y;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x8D: // [sta_abs]
// static void sta_abs () // 0x8d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// put6502memory(savepc,A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_A, " ram[0x%04X] = A;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x8E: // [stx_abs]
// static void stx_abs () // 0x8e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// put6502memory(savepc,X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " ram[0x%04X] = X;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x8F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x90: // [bcc_relative]
// static void bcc_relative () // 0x90
// {
// if ((P & 0x01)==0)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always, " if (C == 0) /* BCC */\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x91: // [sta_indy]
// static void sta_indy () // 0x91
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// savepc += Y;
// put6502memory(savepc,A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
// Oops - forgot 'SAMESEX' test
dumpf (Always, Always | R_Y | R_A, " ram[(unsigned short)(*(((unsigned short *)&ram[0x%04X])+Y))] = A; /* Is (ind),Y handled correctly??? */\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x92: // [sta_indzp]
// static void sta_indzp () // 0x92
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// put6502memory(savepc,A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " ram[temp] = A;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x93: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x94: // [sty_zpx]
// static void sty_zpx () // 0x94
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// put6502memory(savepc,Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " ram[temp] = Y;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x95: // [sta_zpx]
// static void sta_zpx () // 0x95
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// put6502memory(savepc,A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, Always | R_A | R_X, " ram[(unsigned char)(0x%02x + X)] = A;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x96: // [stx_zpy]
// static void stx_zpy () // 0x96
// {
// savepc=get6502memoryFast(PC++)+Y;
// savepc &= 0x00ff;
// put6502memory(savepc,X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_Y | Always, " temp=(0x%04X + Y)&0xFF;\n", temp);
dumpf (Always, Always, " ram[temp] = X;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x97: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x98: // [tya_implied]
// static void tya_implied () // 0x98
// {
// A=Y;
// DO_Z (A);
// DO_N (A);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " A=Y;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x99: // [sta_absy]
// static void sta_absy () // 0x99
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += Y;
// put6502memory(savepc,A);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
tempword (opadd);
dumpf (Always, R_Y | Always, " ram[(unsigned short)(0x%04X + Y)] = A;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9A: // [txs_implied]
// static void txs_implied () // 0x9a
// {
// S=X;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " S=X;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9B: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9C: // [stz_abs]
// static void stz_abs () // 0x9c
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// put6502memory(savepc,0);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " ram[0x%04X] = 0;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9D: // [sta_absx]
// static void sta_absx () // 0x9d
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// put6502memory(savepc,A);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
tempword (opadd);
if ((unsigned short) temp <= 0xFF00) {
dumpf (Always, R_X | Always | R_A, " ram[0x%04X + X /* can't wrap */] = A;\n", temp);
} else {
dumpf (Always, R_X | Always | R_A, " ram[(unsigned short)(0x%04X + X)] = A; /* force efficient wraparound */\n", temp);
}
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9E: // [stz_absx]
// static void stz_absx () // 0x9e
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// put6502memory(savepc,0);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
tempword (opadd);
dumpf (Always, R_X | Always, " ram[(unsigned short)(0x%04X + X)] = 0;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0x9F: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA0: // [ldy_immediate]
// static void ldy_immediate () // 0xa0
// {
// savepc=PC++;
// Y=get6502memory(savepc);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_Y, 0, " Y=0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_Y, " ZN = Y;\n");
// dumpf(R_P_N, R_Y, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA1: // [lda_indx]
// static void lda_indx () // 0xa1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp+=X;\n");
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " A=ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA2: // [ldx_immediate]
// static void ldx_immediate () // 0xa2
// {
// savepc=PC++;
// X=get6502memory(savepc);
// DO_Z (X);
// DO_N (X);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " X=0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA4: // [ldy_zp]
// static void ldy_zp () // 0xa4
// {
// savepc=get6502memoryFast(PC++);
// Y=get6502memory(savepc);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_Y, Always, " Y=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_Y, " ZN = Y;\n");
// dumpf(Always, Always, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA5: // [lda_zp]
// static void lda_zp () // 0xa5
// {
// savepc=get6502memoryFast(PC++);
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_A, Always, " A=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA6: // [ldx_zp]
// static void ldx_zp () // 0xa6
// {
// savepc=get6502memoryFast(PC++);
// X=get6502memory(savepc);
// DO_Z (X);
// DO_N (X);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " X=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA8: // [tay_implied]
// static void tay_implied () // 0xa8
// {
// Y=A;
// DO_Z (Y);
// DO_N (Y);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_Y, R_A, " Y=A;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xA9: // [lda_immediate]
// static void lda_immediate () // 0xa9
// {
// savepc=PC++;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_A, 0, " A=0x%02X;\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAA: // [tax_implied]
// static void tax_implied () // 0xaa
// {
// X=A;
// DO_Z (X);
// DO_N (X);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_X, R_A, " X=A;\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAC: // [ldy_abs]
// static void ldy_abs () // 0xac
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// Y=get6502memory(savepc);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " Y=ram[0x%04X];\n", temp);
dumpf (Always, Always, " DO_Z (Y);\n");
// dumpf(Always, Always, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAD: // [lda_abs]
// static void lda_abs () // 0xad
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
if (temp == 0x2403) {
dumpf (Always, Always, " if(ram[0x2403]==0xFF) {\n");
dumpf (Always, Always, " ram[0x2403]=0; /* NO LONGER DONE IN WRITEMEM() */\n");
dumpf (Always, Always, " A=0xff;\n");
dumpf (Always | R_A, Always, " }\n");
} else {
dumpf (Always | R_A, Always, " A=ram[0x%04X];\n", temp);
}
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAE: // [ldx_abs]
// static void ldx_abs () // 0xae
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// X=get6502memory(savepc);
// DO_Z (X);
// DO_N (X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, Always, " X=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xAF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB0: // [bcs_relative]
// static void bcs_relative () // 0xb0
// {
// if (P & 0x01)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always | R_P_C, " if (C)\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB1: // [lda_indy]
// static void lda_indy () // 0xb1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " temp+=Y;\n");
dumpf (Always, Always, " A=ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB2: // [lda_indzp]
// static void lda_indzp () // 0xb2
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " temp=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (Always, Always, " temp<<=8;\n");
dumpf (Always, Always, " temp|=ram[0x%04X];\n", temp);
dumpf (Always, Always, " A=ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB4: // [ldy_zpx]
// static void ldy_zpx () // 0xb4
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// Y=get6502memory(savepc);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_X | Always, " temp=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always, Always, " Y=ram[temp];\n");
dumpf (Always, Always, " DO_Z (Y);\n");
// dumpf(Always, Always, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB5: // [lda_zpx]
// static void lda_zpx () // 0xb5
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always | R_A, Always | R_X, " A=ram[(unsigned char)(0x%02x + X)];\n", temp);
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf (R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB6: // [ldx_zpy]
// static void ldx_zpy () // 0xb6
// {
// savepc=get6502memoryFast(PC++)+Y;
// savepc &= 0x00ff;
// X=get6502memory(savepc);
// DO_Z (X);
// DO_N (X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always, R_Y | Always, " temp=(0x%04X + Y)&0xFF;\n", temp);
dumpf (Always, Always, " ZN=ram[temp];\n");
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB8: // [clv_implied]
// static void clv_implied () // 0xb8
// {
// P &= 0xbf;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " P &= 0xbf; /* CLV */\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xB9: // [lda_absy]
// static void lda_absy () // 0xb9
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
if ((unsigned short) temp <= 0xFF00) {
dumpf (Always | R_A, R_Y | Always, " A=ram[0x%04X + Y /* can't wrap */];\n", temp);
} else {
dumpf (Always | R_A, R_Y | Always, " A=ram[(unsigned short)(0x%04X + Y)]; /* perform efficient masking/wraparound */\n", temp);
}
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBA: // [tsx_implied]
// static void tsx_implied () // 0xba
// {
// X=S;
// DO_Z (X);
// DO_N (X);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " X=S;\n");
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBC: // [ldy_absx]
// static void ldy_absx () // 0xbc
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// Y=get6502memory(savepc);
// DO_Z (Y);
// DO_N (Y);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_Y | Always, R_X | Always, " Y=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_Z | R_P_N, R_Y, " ZN = Y;\n");
// dumpf(Always, Always, " DO_N (Y);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBD: // [lda_absx]
// static void lda_absx () // 0xbd
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// A=get6502memory(savepc);
// DO_Z (A);
// DO_N (A);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
if ((unsigned short) temp <= 0xFF00) {
dumpf (R_A, R_X | Always, " A=ram[0x%04X + X /* can't wrap */];\n", temp);
} else {
dumpf (R_A, R_X | Always, " A=ram[(unsigned short)(0x%04X + X)];\n", temp);
}
dumpf (R_P_Z | R_P_N, R_A, " ZN = A;\n");
// dumpf(R_P_N, R_A, " DO_N (A);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBE: // [ldx_absy]
// static void ldx_absy () // 0xbe
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// X=get6502memory(savepc);
// DO_Z (X);
// DO_N (X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always, R_Y | Always, " X=ram[(unsigned short)(0x%04X + Y)];\n", temp);
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xBF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC0: // [cpy_immediate]
// static void cpy_immediate () // 0xc0
// {
// savepc=PC++;
// value=get6502memory(savepc);
// if (Y+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=Y/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE, Always, " ZN=0x%02X;\n", temp);
dumpf (R_P_C, R_Y | R_VALUE, " C = (Y+0x100-ZN>0xff); /* Can probably do better? */\n");
dumpf (R_P_Z | R_P_N, R_Y | R_VALUE, " ZN=Y/*+0x100*/-ZN;\n");
// TODO: continue adding DO_Z (value) from here on down...
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC1: // [cmp_indx]
// static void cmp_indx () // 0xc1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_VALUE, Always | R_X, " ZN=ram[(unsigned short)(0x%04X + X /* surely not? + 1*/)];\n", temp);
dumpf (R_VALUE, R_VALUE, " ZN<<=8;\n");
dumpf (Always | R_VALUE, R_X | Always | R_VALUE, " ZN|=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_Z | R_P_N, Always | R_VALUE, " ZN=ram[ZN];\n");
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (Always, Always, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC2: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC4: // [cpy_zp]
// static void cpy_zp () // 0xc4
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// if (Y+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=Y/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_Y | R_VALUE, " C = (Y+0x100-ZN>0xff);\n");
dumpf (Always, Always, " ZN=Y/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC5: // [cmp_zp]
// static void cmp_zp () // 0xc5
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (Always, Always, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC6: // [dec_zp]
// static void dec_zp () // 0xc6
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// value--;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always, Always, " ZN=ram[0x%04X]-1;\n", temp);
dumpf (Always, Always, " ram[0x%04X] = ZN;\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC8: // [iny_implied]
// static void iny_implied () // 0xc8
// {
// Y++;
// DO_Z (Y);
// DO_N (Y);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_Y, R_Y, " Y++;\n");
dumpf (R_P_Z | R_P_N, R_Y, " ZN = Y;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xC9: // [cmp_immediate]
// static void cmp_immediate () // 0xc9
// {
// savepc=PC++;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE, 0, " ZN=0x%02X;\n", temp);
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCA: // [dex_implied]
// static void dex_implied () // 0xca
// {
// X--;
// DO_Z (X);
// DO_N (X);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_X, R_X, " X--;\n");
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCC: // [cpy_abs]
// static void cpy_abs () // 0xcc
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// if (Y+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=Y/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_VALUE, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_Y | R_VALUE, " C = (Y + 0x100 - ZN > 0xff);\n ");
dumpf (R_P_Z | R_P_N, R_Y | R_VALUE, " ZN = Y /* +0x100 */ - ZN;\n ");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCD: // [cmp_abs]
// static void cmp_abs () // 0xcd
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_VALUE, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCE: // [dec_abs]
// static void dec_abs () // 0xce
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// value--;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd); /* TODO* /* looking for fe and converting to C */
dumpf (R_P_Z | R_P_N | Always, Always, " ZN=--ram[0x%04X];\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
// dumpf (Always, Always|R_P_Z|R_P_N, " ram[0x%04X] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xCF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD0: // [bne_relative]
// static void bne_relative () // 0xd0
// {
// if ((P & 0x02)==0)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always | R_P_Z, " if (ZN != 0) /* If Z flag is clear, ie last val was non-zero */\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD1: // [cmp_indy]
// static void cmp_indy () // 0xd1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (Always | R_VALUE, Always, " ZN=ram[(unsigned short)(0x%04X/*surely not? + 1*/)];\n", temp);
dumpf (R_VALUE, R_VALUE, " ZN<<=8;\n");
dumpf (Always | R_VALUE, Always | R_VALUE, " ZN|=ram[0x%04X];\n", temp);
dumpf (R_VALUE, R_Y | Always | R_VALUE, " ZN=ram[(unsigned short)(ZN + Y)];\n");
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD2: // [cmp_indzp]
// static void cmp_indzp () // 0xd2
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_VALUE, Always, " ZN=ram[(unsigned short)(0x%04X /* surely not? + 1*/)];\n", temp);
dumpf (R_VALUE, R_VALUE, " ZN<<=8;\n");
dumpf (R_VALUE, R_VALUE, " ZN|=ram[0x%04X];\n", temp);
dumpf (R_VALUE, R_VALUE | Always, " ZN=ram[ZN];\n");
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD4: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD5: // [cmp_zpx]
// static void cmp_zpx () // 0xd5
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (R_VALUE, R_X | Always, " ZN=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always | R_VALUE, Always | R_VALUE, " ZN=ram[ZN];\n");
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD6: // [dec_zpx]
// static void dec_zpx () // 0xd6
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// value--;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_VALUE, R_X, " ZN=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always | R_VALUE, Always | R_VALUE, " ZN=ram[ZN];\n");
dumpf (R_VALUE | R_P_Z | R_P_N, R_VALUE, " ZN--;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, Always | R_VALUE, " ram[ZN] = ZN;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD8: // [cld_implied]
// static void cld_implied () // 0xd8
// {
// P &= 0xf7;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " P &= 0xf7; //cld\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xD9: // [cmp_absy]
// static void cmp_absy () // 0xd9
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_VALUE, R_Y | Always, " ZN=ram[(unsigned short)(0x%04X + Y)];\n", temp);
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xDA: // [phx_implied]
// static void phx_implied () // 0xda
// {
// put6502memory(0x100+S--,X);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0xDB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xDC: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xDD: // [cmp_absx]
// static void cmp_absx () // 0xdd
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// value=get6502memory(savepc);
// if (A+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=A/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_VALUE, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_P_C, R_A | R_VALUE, " C = (A+0x100-ZN>0xff);\n");
dumpf (R_P_Z | R_P_N, R_A | R_VALUE, " ZN=A/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xDE: // [dec_absx]
// static void dec_absx () // 0xde
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// value--;
// DO_Z (value);
// DO_N (value);
// put6502memory(savepc,value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (Always | R_VALUE, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)];\n", temp);
dumpf (R_VALUE | R_P_Z | R_P_N, R_VALUE, " ZN--;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
dumpf (Always, R_X | R_VALUE | Always, " ram[(unsigned short)(0x%04X + X)] = ZN;\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xDF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE0: // [cpx_immediate]
// static void cpx_immediate () // 0xe0
// {
// savepc=PC++;
// value=get6502memory(savepc);
// if (X+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=X/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE, 0, " ZN=0x%02X;\n", temp);
dumpf (R_P_C, R_X | R_VALUE, " C = (X + 0x100 - ZN > 0xff);\n ");
dumpf (R_P_Z | R_P_N, R_VALUE | R_X, " ZN=X/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE1: // [sbc_indx]
// static void sbc_indx () // 0xe1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// tmp += X;
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// SBC (savepc);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_VALUE, R_VALUE | R_X, " temp+=X;\n");
dumpf (Always | R_VALUE, Always, " ZN=ram[(unsigned short)(0x%04X + 1 /* better to add in printf? */)];\n", temp);
dumpf (R_VALUE, R_VALUE, " ZN<<=8;\n");
dumpf (R_VALUE, R_VALUE | Always, " temp|=ram[0x%04X];\n", temp);
dumpf (R_P_Z | R_P_N, Always | R_VALUE, " ZN=ram[temp];\n");
dumpf (Always, Always, " crash(0x%04X,0x%02X);\n", opadd, opcode);
flush (R_FLUSH);
/* NO FLUSH */
return;
case 0xE2: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE4: // [cpx_zp]
// static void cpx_zp () // 0xe4
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// if (X+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=X/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_X | R_VALUE, " C = (X + 0x100 - ZN > 0xff);\n ");
dumpf (R_P_Z | R_P_N, R_X | R_VALUE, " ZN=X/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE5: // [sbc_zp]
// static void sbc_zp () // 0xe5
// {
// savepc=get6502memoryFast(PC++);
// SBC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_P_C | R_P_D, " SBC(ram[0x%04X]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE6: // [inc_zp]
// static void inc_zp () // 0xe6
// {
// savepc=get6502memoryFast(PC++);
// value=get6502memory(savepc);
// value++;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_P_Z | R_P_N | Always, Always, " ZN=++ram[0x%04X];\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N(value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE8: // [inx_implied]
// static void inx_implied () // 0xe8
// {
// X++;
// DO_Z (X);
// DO_N (X);
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (R_X, R_X, " X++;\n");
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xE9: // [sbc_immediate]
// static void sbc_immediate () // 0xe9
// {
// savepc=PC++;
// SBC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_P_C | R_P_D, " SBC(0x%02X);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xEA: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xEB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xEC: // [cpx_abs]
// static void cpx_abs () // 0xec
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// if (X+0x100-value>0xff) P |= 0x01; else P &= 0xfe;
// value=X/*+0x100*/-value;
// DO_Z (value);
// DO_N (value);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (R_VALUE, Always, " ZN=ram[0x%04X];\n", temp);
dumpf (R_P_C, R_X | R_VALUE, " C = (X + 0x100 - ZN > 0xff);\n ");
dumpf (R_P_Z | R_P_N, R_VALUE | R_X, " ZN=X/*+0x100*/-ZN;\n");
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xED: // [sbc_abs]
// static void sbc_abs () // 0xed
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// SBC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_P_C | R_P_D, " SBC(ram[0x%04X]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xEE: // [inc_abs]
// static void inc_abs () // 0xee
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// value=get6502memory(savepc);
// value++;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
tempword (opadd);
dumpf (R_P_Z | R_P_N | Always, Always, " ZN=++ram[0x%04X];\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xEF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF0: // [beq_relative]
// static void beq_relative () // 0xf0
// {
// if (P & 0x02)
// {
// savepc=get6502memoryFast(PC++);
// if (savepc & 0x80) savepc -= 0x100;
// if ((savepc >> 8) != (PC >> 8))
// clockticks++;
// PC += savepc;
// clockticks++;
// }
// else
// PC++;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
temp = rom[opadd + 1];
if (temp & 0x80)
temp -= 0x100;
dumpf (Always, Always | R_P_Z, " if (ZN == 0) /* Z flag is set, ie last val was zero */\n");
dumpf (Always, Always, " {\n");
conditional_clockticks (1);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
dumpf (Always, Always, " PC = 0x%04x;\n", (opadd + temp + 2) & 0x7FFF);
conditional_flush (" return;\n");
dumpf (Always, Always, " }\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF1: // [sbc_indy]
// static void sbc_indy () // 0xf1
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// SBC (savepc);
// clockticks += 5;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (5);
temp = rom[opadd + 1];
dumpf (R_VALUE, Always, " ZN=ram[(unsigned short)(0x%04X + 1 /* move to printf */)];\n", temp);
dumpf (R_VALUE, R_VALUE, " ZN<<=8;\n");
dumpf (Always | R_VALUE, Always, " ZN|=ram[0x%04X];\n", temp);
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_P_C | R_P_D, " SBC(ram[(unsigned short)(ZN)]+Y); // Be careful here... ZN trickiness...\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF2: // [sbc_indzp]
// static void sbc_indzp () // 0xf2
// {
// unsigned char tmp=get6502memoryFast(PC++);
// savepc=get6502memory(tmp++);
// savepc |= get6502memory(tmp) << 8;
// SBC (savepc);
// clockticks += 3;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (3);
temp = rom[opadd + 1];
dumpf (R_VALUE, Always, " ZN=ram[(unsigned short)(0x%04X + 1)];\n", temp);
dumpf (R_VALUE, R_VALUE, " temp<<=8;\n");
dumpf (Always | R_VALUE, Always | R_VALUE, " ZN|=ram[0x%04X];\n", temp);
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_VALUE | R_P_C | R_P_D, " SBC(ram[ZN]); // beware ZN expansion\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF3: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF4: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF5: // [sbc_zpx]
// static void sbc_zpx () // 0xf5
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// SBC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
temp = rom[opadd + 1];
dumpf (Always | R_VALUE, R_X | Always, " ZN=(0x%04X + X)&0xFF;\n", temp);
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, Always | R_A | R_VALUE | R_P_C | R_P_D, " SBC(ram[ZN]); // beware ZN expansion\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF6: // [inc_zpx]
// static void inc_zpx () // 0xf6
// {
// savepc=get6502memoryFast(PC++)+X;
// savepc &= 0x00ff;
// value=get6502memory(savepc);
// value++;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 6;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (6);
temp = rom[opadd + 1];
dumpf (R_VALUE, R_X | Always, " ZN=(0x%04X + X)&0xFF;\n", temp);
dumpf (R_VALUE | R_P_Z | R_P_N, Always | R_VALUE, " ZN=ram[ZN]+1;\n");
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF7: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF8: // [sed_implied]
// static void sed_implied () // 0xf8
// {
// P |= 0x08;
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
dumpf (Always, Always, " P |= 0x08; // sed\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xF9: // [sbc_absy]
// static void sbc_absy () // 0xf9
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+Y) >> 8))
// clockticks++;
// savepc += Y;
// SBC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_P_C | R_P_N | R_P_Z | R_P_V, R_Y | Always | R_P_C | R_P_D, " SBC(ram[(unsigned short)(0x%04X + Y)]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFA: // [plx_implied]
// static void plx_implied () // 0xfa
// {
// X=get6502memory(++S+0x100);
// DO_Z (X);
// DO_N (X);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
dumpf (R_X, Always | R_S, " X=stack[++S];\n");
dumpf (R_P_Z | R_P_N, R_X, " ZN = X;\n");
// dumpf(R_P_N, R_X, " DO_N (X);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFB: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFC: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFD: // [sbc_absx]
// static void sbc_absx () // 0xfd
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// if ((savepc >> 8) != ((savepc+X) >> 8))
// clockticks++;
// savepc += X;
// SBC (savepc);
// clockticks += 4;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (4);
tempword (opadd);
dumpf (Always | R_A | R_P_C | R_P_N | R_P_Z | R_P_V, R_X | Always | R_A | R_P_C | R_P_D, " SBC(ram[(unsigned short)(0x%04X + X)]);\n", temp);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFE: // [inc_absx]
// static void inc_absx () // 0xfe
// {
// savepc=get6502memoryFast(PC++);
// savepc |= get6502memoryFast(PC++) << 8;
// savepc += X;
// value=get6502memory(savepc);
// value++;
// put6502memory(savepc,value);
// DO_Z (value);
// DO_N (value);
// clockticks += 7;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (7);
tempword (opadd);
dumpf (R_P_Z | R_P_N | R_VALUE, R_X | Always, " ZN=ram[(unsigned short)(0x%04X + X)] + 1;\n", temp);
dumpf (Always, R_VALUE, " ram[0x%04X] = ZN;\n", temp);
// XX: dumpf(R_P_Z|R_P_N, R_VALUE, " ZN = ZN;\n");
// dumpf(R_P_N, R_VALUE, " DO_N (value);\n");
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
case 0xFF: // [nop_implied]
// static void nop_implied () // 0x02
// {
// clockticks += 2;
// }
dumpf (Always, Always, "case 0x%04X: L_%04x: //%02X %02X %02X\n", opadd, opadd, opcode, rom[opadd + 1], rom[opadd + 2]);
unconditional_clockticks (2);
if (DEBUG) { dumpf (Always, Always, " //trace_PC(0x%04X);\n", opadd); }
/* NO FLUSH */
return;
}
}
void do_rom (char *filename, unsigned short base) {
FILE *fp;
fp = fopen (filename, "rb");
if (fp == NULL) {
fprintf (stderr, "Error opening rom %s\n", filename);
exit (1);
}
fread (rom + base, 1, 0x800, fp);
fclose (fp);
}
int main (void) {
memset (rom, 0, sizeof (rom));
memset (rom + 0x4000, 0xb0, 0x1000);
do_rom ("roms/036800.02", 0x4800);
do_rom ("roms/036799.01", 0x5000);
do_rom ("roms/036430.02", 0x6000);
do_rom ("roms/036431.02", 0x6800);
do_rom ("roms/036432.02", 0x7000);
do_rom ("roms/036433.03", 0x7800);
rom[0x2c00] = 0xff;
rom[0x2c01] = 0xff;
rom[0x2c02] = 0xff;
rom[0x2c03] = 0xff;
rom[0x2c04] = 0xff;
rom[0x2c05] = 0xff;
rom[0x2c06] = 0xff;
rom[0x2c07] = 0xff;
rom[0x2c08] = 0xff;
rom[0x2c09] = 0xff;
rom[0x2c0a] = 0xff;
rom[0x2c0b] = 0xff;
rom[0x2c0c] = 0xff;
rom[0x2c0d] = 0xff;
rom[0x2c0e] = 0xff;
rom[0x2c0f] = 0xff;
rom[0x2800] = 0x0;
rom[0x2801] = 0x0;
rom[0x2802] = 0xff;
rom[0x2803] = 0x0;
fp = fopen ("hitlist.bin", "rb");
if (fp == NULL)
exit (1);
fread (hitlist, 1, 0x8000, fp);
fclose (fp);
/*
Missing instructions. Unfortunately adding them here does
not add all code reachable from these instructions, just the
instructions themselves (I think)
game.c:20178: label `L_7e71' used but not defined
etc
*/
hitlist[0x7e71] = 1;
hitlist[0x7d8f] = 1;
hitlist[0x7d8b] = 1;
hitlist[0x7516] = 1;
hitlist[0x6648] = 1;
hitlist[0x4c80] = 1;
hitlist[0x4c01] = 1;
fprintf (stdout, "\n\nunsigned short PC=0x%02X%02X;\n", rom[0x7ffd], rom[0x7ffc]);
fprintf (stdout, "unsigned short NMISTART=0x%02X%02X;\n", rom[0x7ffb], rom[0x7ffa]);
fp = fopen ("gtop.c", "r");
if (fp == NULL)
abort ();
while (fgets (newline, sizeof (newline) - 1, fp)) {
fprintf (stdout, "%s", newline);
}
fclose (fp);
for (sa = 0; sa < 0x8000; sa++) {
if (hitlist[sa] == 0)
continue;
translate (sa, rom[sa]);
}
fp = fopen ("gbot.c", "r");
if (fp == NULL)
abort ();
while (fgets (newline, sizeof (newline) - 1, fp)) {
fprintf (stdout, "%s", newline);
}
fclose (fp);
}