home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
AmigActive 6
/
AACD06.ISO
/
AACD
/
Emulation
/
Atari800
/
monitor.c
< prev
next >
Wrap
C/C++ Source or Header
|
1998-02-25
|
22KB
|
1,124 lines
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#ifdef VMS
#include <unixio.h>
#include <file.h>
#else
#include <fcntl.h>
#endif
#include <stdlib.h>
static char *rcsid = "$Id: monitor.c,v 1.12 1996/10/09 22:02:07 david Exp $";
#include "atari.h"
#include "cpu.h"
#include "antic.h"
#include "gtia.h"
#include "pia.h"
#include "pokey11.h"
#include "mem.h"
#define FALSE 0
#define TRUE 1
extern int count[256];
extern UBYTE memory[65536];
extern UBYTE PORTA_mask,PORTB_mask;
extern int ypos;
#ifdef TRACE
int tron = FALSE;
#endif
unsigned int disassemble (UWORD addr1, UWORD addr2);
void show_opcode (UBYTE instr);
void show_operand (UBYTE instr);
char *get_token (char *string)
{
static char *s;
char *t;
if (string) s = string; /* New String */
while (*s == ' ') s++; /* Skip Leading Spaces */
if (*s)
{
t = s; /* Start of String */
while (*s != ' ' && *s) /* Locate End of String */
{
s++;
}
if (*s == ' ') /* Space Terminated ? */
{
*s = '\0'; /* C String Terminator */
s++; /* Point to Next Char */
}
}
else
{
t = NULL;
}
return t; /* Pointer to String */
}
void ReadDec(char *header,int *destination)
{
char buffer[256];
int tmp;
char *ep;
printf("%s (%d) = ",header,*destination);
gets(buffer);
if (buffer[0]) {
tmp=strtol(buffer,&ep,0);
if (ep>buffer)
*destination=tmp;
}
}
int get_hex (char *string, UWORD *hexval)
{
int ihexval;
char *t;
t = get_token(string);
if (t)
{
if (!strcmp(t,"PC")) {
*hexval = regPC;
return 1;
}
if (!strcmp(t,"S")) {
*hexval = regS+0x100;
return 1;
}
sscanf (t,"%x",&ihexval);
*hexval = ihexval;
return 1;
}
return 0;
}
int monitor (void)
{
UWORD addr;
UWORD break_addr;
char s[128];
int p;
addr = 0;
CPU_GetStatus ();
while (TRUE)
{
char *t;
printf ("> ");
fflush(stdout);
if (gets (s) == NULL)
{
printf("\n> CONT\n");
strcpy(s, "CONT");
}
for (p=0;s[p]!=0;p++)
if (islower(s[p]))
s[p] = toupper(s[p]);
t = get_token(s);
if (t == NULL)
{
continue;
}
if (strcmp(t,"BREAK") == 0)
{
get_hex (NULL, &break_addr);
}
else if (strcmp(t,"CONT") == 0)
{
int i;
for (i=0;i<256;i++)
count[i] = 0;
return 1;
}
else if (strcmp(t,"DLIST") == 0)
{
UWORD dlist = DLISTINIT;
UWORD addr;
int done = FALSE;
int nlines = 0;
while (!done)
{
UBYTE IR;
printf ("%04x: ", dlist);
IR = memory[dlist++];
if (IR & 0x80)
printf ("DLI ");
switch (IR & 0x0f)
{
case 0x00 :
printf ("%d BLANK", ((IR >> 4) & 0x07) + 1);
break;
case 0x01 :
addr = memory[dlist] | (memory[dlist+1] << 8);
if (IR & 0x40)
{
printf ("JVB %04x ", addr);
dlist += 2;
done = TRUE;
}
else
{
printf ("JMP %04x ", addr);
dlist = addr;
}
break;
default :
if (IR & 0x40)
{
addr = memory[dlist] | (memory[dlist+1] << 8);
dlist += 2;
printf ("LMS %04x ", addr);
}
if (IR & 0x20)
printf ("VSCROL ");
if (IR & 0x10)
printf ("HSCROL ");
printf ("MODE %x ", IR & 0x0f);
}
printf ("\n");
nlines++;
if (nlines == 15)
{
char gash[4];
printf ("Press return to continue: ");
gets (gash);
nlines = 0;
}
}
}
else if (strcmp(t,"SETPC") == 0)
{
get_hex (NULL, &addr);
regPC = addr;
}
else if (strcmp(t,"SETS") == 0)
{
get_hex (NULL, &addr);
regS = addr & 0xff;
}
else if (strcmp(t,"SETA") == 0)
{
get_hex (NULL, &addr);
regA = addr & 0xff;
}
else if (strcmp(t,"SETX") == 0)
{
get_hex (NULL, &addr);
regX = addr & 0xff;
}
else if (strcmp(t,"SETY") == 0)
{
get_hex (NULL, &addr);
regY = addr & 0xff;
}
else if (strcmp(t,"SETN") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetN;
else
ClrN;
}
else if (strcmp(t,"SETV") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetV;
else
ClrV;
}
else if (strcmp(t,"SETB") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetB;
else
ClrB;
}
else if (strcmp(t,"SETD") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetD;
else
ClrD;
}
else if (strcmp(t,"SETI") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetI;
else
ClrI;
}
else if (strcmp(t,"SETZ") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetZ;
else
ClrZ;
}
else if (strcmp(t,"SETC") == 0)
{
get_hex (NULL, &addr);
if (addr)
SetC;
else
ClrC;
}
#ifdef TRACE
else if (strcmp(t,"TRON") == 0)
tron = TRUE;
else if (strcmp(t,"TROFF") == 0)
tron = FALSE;
#endif
else if (strcmp(t,"PROFILE") == 0)
{
int i;
for (i=0;i<10;i++)
{
int max, instr;
int j;
max = count[0];
instr = 0;
for (j=1;j<256;j++)
{
if (count[j] > max)
{
max = count[j];
instr = j;
}
}
if (max > 0)
{
count[instr] = 0;
printf ("%02x has been executed %d times\n",
instr, max);
}
else
{
printf ("Instruction Profile data not available\n");
break;
}
}
}
else if (strcmp(t,"SHOW") == 0)
{
printf ("PC=%04x, A=%02x, S=%02x, X=%02x, Y=%02x, P=%02x\n",
regPC,
regA,
regS,
regX,
regY,
regP);
}
else if (strcmp(t,"ROM") == 0)
{
UWORD addr1;
UWORD addr2;
int status;
status = get_hex (NULL, &addr1);
status |= get_hex (NULL, &addr2);
if (status)
{
SetROM (addr1, addr2);
printf ("Changed Memory from %4x to %4x into ROM\n",
addr1, addr2);
}
else
{
printf ("*** Memory Unchanged (Missing Parameter) ***\n");
}
}
else if (strcmp(t,"RAM") == 0)
{
UWORD addr1;
UWORD addr2;
int status;
status = get_hex (NULL, &addr1);
status |= get_hex (NULL, &addr2);
if (status)
{
SetRAM (addr1, addr2);
printf ("Changed Memory from %4x to %4x into RAM\n",
addr1, addr2);
}
else
{
printf ("*** Memory Unchanged (Missing Parameter) ***\n");
}
}
else if (strcmp(t,"WRITE") == 0)
{
UWORD addr1;
UWORD addr2;
int status;
status = get_hex (NULL, &addr1);
status |= get_hex (NULL, &addr2);
if (status)
{
int fd;
fd = open ("memdump.dat", O_CREAT | O_TRUNC | O_WRONLY, 0777);
if (fd == -1)
{
perror ("open");
return 0;
}
write (fd, &memory[addr1], addr2 - addr1 + 1);
close (fd);
}
}
else if (strcmp(t,"SUM") == 0)
{
UWORD addr1;
UWORD addr2;
int status;
status = get_hex (NULL, &addr1);
status |= get_hex (NULL, &addr2);
if (status)
{
int sum = 0;
int i;
for (i=addr1;i<=addr2;i++)
sum += (UWORD)memory[i];
printf ("SUM: %x\n", sum);
}
}
else if (strcmp(t,"D") == 0)
{
int addr1;
int addr2;
UWORD xaddr1;
UWORD xaddr2;
UWORD temp;
int i;
xaddr1 = addr;
xaddr2 = 0;
get_hex (NULL, &xaddr1);
get_hex (NULL, &xaddr2);
addr1 = xaddr1;
addr2 = xaddr2;
if (addr2 == 0) addr2 = addr1 + 255;
addr = addr2 + 1;
while (addr1 <= addr2)
{
temp = addr1;
printf ("%4x : ",temp);
for (i=0;i<16;i++)
{
printf ("%2x ",memory[temp]);
temp++;
if (temp > addr2) break;
}
temp = addr1;
printf ("\t");
for (i=0;i<16;i++)
{
if (isalnum(memory[temp]))
{
printf ("%c",memory[temp]);
}
else
{
printf (".");
}
temp++;
if (temp > addr2) break;
}
printf ("\n");
addr1 += 16;
}
}
else if (strcmp(t,"M") == 0)
{
UWORD addr;
UWORD temp;
get_hex (NULL, &addr);
while (get_hex(NULL, &temp))
{
memory[addr] = (UBYTE)temp;
addr++;
}
}
else if (strcmp(t,"Y") == 0)
{
UWORD addr1;
UWORD addr2;
addr1 = addr;
addr2 = 0;
get_hex (NULL, &addr1);
get_hex (NULL, &addr2);
addr = disassemble (addr1,addr2);
}
else if (strcmp(t,"ANTIC") == 0)
{
printf ("DMACTL=%02x CHACTL=%02x DLIST=%04x "
"HSCROL=%02x VSCROL=%02x\n",
DMACTL, CHACTL, DLIST , HSCROL, VSCROL);
printf ("PMBASE=%02x CHBASE=%02x WSYNC= xx "
"VCOUNT=%02x PENH= xx PENV= xx\n",
PMBASE, CHBASE, ypos >> 1);
printf ("NMIEN= %02x NMIRES=xx\n", NMIEN);
printf ("YPos = %04x\n",ypos);
}
else if (strcmp(t,"POKEY") == 0)
{
printf ("IRQEN=%02x IRQST=%02x KBCODE=%02x "
"SKSTAT=%02x AUDCTL=%02x\n",
IRQEN,IRQST,KBCODE,SKSTAT,AUDCTL);
printf ("AUDF1=%02x AUDC1=%02x AUDcnt1=%08lx "
"AUDmax1=%08lx\n",
AUDF[0],AUDC[0],Div_n_irq[0],Div_n_max[0]);
printf ("AUDF2=%02x AUDC2=%02x AUDcnt2=%08lx "
"AUDmax2=%08lx\n",
AUDF[1],AUDC[1],Div_n_irq[1],Div_n_max[1]);
printf ("AUDF3=%02x AUDC3=%02x AUDcnt3=%08lx "
"AUDmax3=%08lx\n",
AUDF[2],AUDC[2],Div_n_irq[2],Div_n_max[2]);
printf ("AUDF4=%02x AUDC4=%02x AUDcnt4=%08lx "
"AUDmax4=%08lx\n",
AUDF[3],AUDC[3],Div_n_irq[3],Div_n_max[3]);
}
else if (strcmp(t,"PIA") == 0)
{
printf("PORTA=%02x PORTB=%02x\n",
PORTA,PORTB);
printf("PACTL=%02x PBCTL=%02x\n",
PACTL,PBCTL);
printf("PAmsk=%02x PBmsk=%02x\n",
PORTA_mask,PORTB_mask);
}
else if (strcmp(t,"GTIA") == 0)
{
printf ("HPOSP0=%02x HPOSP1=%02x HPOSP2=%02x "
"HPOSP3=%02x HPOSM0=%02x HPOSM1=%02x\n",
HPOSP0, HPOSP1, HPOSP2, HPOSP3, HPOSM0, HPOSM1);
printf ("HPOSM2=%02x HPOSM3=%02x SIZEP0=%02x "
"SIZEP1=%02x SIZEP2=%02x SIZEP3=%02x\n",
HPOSM2, HPOSM3, SIZEP0, SIZEP1, SIZEP2, SIZEP3);
printf ("SIZEM= %02x GRAFP0=%02x GRAFP1=%02x "
"GRAFP2=%02x GRAFP3=%02x GRAFM =%02x\n",
SIZEM, GRAFP0, GRAFP1, GRAFP2, GRAFP3, GRAFM);
printf ("COLPM0=%02x COLPM1=%02x COLPM2=%02x "
"COLPM3=%02x COLPF0=%02x COLPF1=%02x\n",
COLPM0, COLPM1, COLPM2, COLPM3, COLPF0, COLPF1);
printf ("COLPF2=%02x COLPF3=%02x COLBK= %02x "
"PRIOR= %02x GRACTL=%02x\n",
COLPF2, COLPF3, COLBK, PRIOR, GRACTL);
/* printf ("TRIG0= %02x TRIG1= %02x TRIG2= %02x "
"TRIG3= %02x\n",
Atari_TRIG(0),Atari_TRIG(1),Atari_TRIG(2),Atari_TRIG(3)); */
}
else if (strcmp(t,"TIMING") == 0)
{
ReadDec("Middle horizontal cycle",&cc_middle);
ReadDec("DLI reaction delay",&dli_delay);
ReadDec("Cycles after WSYNC",&after_wsync);
ReadDec("Cycles before DMA",&before_dma);
ReadDec("WSYNC bonus cycles",&wsync_bonus);
ReadDec("VSYNC line",&vsync_pos);
}
else if (strcmp(t,"HELP") == 0 || strcmp(t,"?") == 0)
{
printf ("SET{PC,A,S,X,Y} hexval - Set Register Value\n"
"SET{N,V,B,D,I,Z,C} hexval - Set Flag Value\n"
"D [startaddr] [endaddr] - Display Memory\n"
"M [startaddr] [hexval...] - Modify Memory\n"
"Y [startaddr] [endaddr] - Disassemble Memory\n"
"ROM addr1 addr2 - Convert Memory Block into ROM\n"
"RAM addr1 addr2 - Convert Memory Block into RAM\n"
"CONT - Continue\n"
"SHOW - Show Registers\n"
"WRITE startaddr endaddr - Write specified area of memory to memdump.dat\n"
"SUM [startaddr] [endaddr] - SUM of specified memory range\n"
#ifdef TRACE
"TRON - Trace On\n"
"TROFF - Trace Off\n"
#endif
"ANTIC - Display ANTIC registers\n"
"GTIA - Display GTIA registers\n"
"PIA - Display PIA registers\n"
"POKEY - Display POKEY registers\n"
"DLIST - Display current display list\n"
"PROFILE - Display profiling statistics\n"
"TIMING - Setup horizontal timing\n"
"QUIT - Quit Emulation\n"
"HELP or ? - This Text\n");
}
else if (strcmp(t,"QUIT") == 0)
{
return 0;
}
else
{
printf ("Invalid command.\n");
}
}
}
static UWORD addr;
unsigned int disassemble (UWORD addr1, UWORD addr2)
{
UBYTE instr;
int count;
addr = addr1;
count = (addr2 == 0) ? 20 : 0;
while (addr < addr2 || count > 0)
{
printf ("%x\t",addr);
instr = memory[addr];
addr++;
show_opcode (instr);
show_operand (instr);
printf ("\n");
if (count > 0) count--;
}
return addr;
}
void show_opcode (UBYTE instr)
{
switch (instr)
{
case 0x6d : case 0x65 : case 0x69:
case 0x79 : case 0x7d : case 0x61 :
case 0x71 : case 0x75 :
printf ("ADC");
break;
case 0x2d : case 0x25 : case 0x29 :
case 0x39 : case 0x3d : case 0x21 :
case 0x31 : case 0x35 :
printf ("AND");
break;
case 0x0e : case 0x06 : case 0x1e :
case 0x16 :
printf ("ASL");
break;
case 0x0a :
printf ("ASL\tA");
break;
case 0x90 :
printf ("BCC");
break;
case 0xb0 :
printf ("BCS");
break;
case 0xf0 :
printf ("BEQ");
break;
case 0x2c : case 0x24 :
printf ("BIT");
break;
case 0x30 :
printf ("BMI");
break;
case 0xd0 :
printf ("BNE");
break;
case 0x10 :
printf ("BPL");
break;
case 0x00 :
printf ("BRK");
break;
case 0x50 :
printf ("BVC");
break;
case 0x70 :
printf ("BVS");
break;
case 0x18 :
printf ("CLC");
break;
case 0xd8 :
printf ("CLD");
break;
case 0x58 :
printf ("CLI");
break;
case 0xb8 :
printf ("CLV");
break;
case 0xcd : case 0xc5 : case 0xc9 :
case 0xdd : case 0xd9 : case 0xc1 :
case 0xd1 : case 0xd5 :
printf ("CMP");
break;
case 0xec : case 0xe4 : case 0xe0 :
printf ("CPX");
break;
case 0xcc : case 0xc4 : case 0xc0 :
printf ("CPY");
break;
case 0xce : case 0xc6 : case 0xde :
case 0xd6 :
printf ("DEC");
break;
case 0xca :
printf ("DEX");
break;
case 0x88 :
printf ("DEY");
break;
case 0x4d : case 0x45 : case 0x49 :
case 0x5d : case 0x59 : case 0x41 :
case 0x51 : case 0x55 :
printf ("EOR");
break;
case 0xff : /* [unofficial] */
printf ("ESC");
break;
case 0xee : case 0xe6 : case 0xfe :
case 0xf6 :
printf ("INC");
break;
case 0xe8 :
printf ("INX");
break;
case 0xc8 :
printf ("INY");
break;
case 0x4c : case 0x6c :
printf ("JMP");
break;
case 0x20 :
printf ("JSR");
break;
case 0xa3 : case 0xa7 : case 0xaf : /* [unofficial] */
case 0xb3 : case 0xb7 : case 0xbf :
printf ("LAX");
break;
case 0xad : case 0xa5 : case 0xa9 :
case 0xbd : case 0xb9 : case 0xa1 :
case 0xb1 : case 0xb5 :
printf ("LDA");
break;
case 0xae : case 0xa6 : case 0xa2 :
case 0xbe : case 0xb6 :
printf ("LDX");
break;
case 0xac : case 0xa4 : case 0xa0 :
case 0xbc : case 0xb4 :
printf ("LDY");
break;
case 0x4e : case 0x46 : case 0x5e :
case 0x56 :
printf ("LSR");
break;
case 0x4a :
printf ("LSR\tA");
break;
case 0xea :
printf ("NOP");
break;
case 0x0d : case 0x05 : case 0x09 :
case 0x1d : case 0x19 : case 0x01 :
case 0x11 : case 0x15 :
printf ("ORA");
break;
case 0x48 :
printf ("PHA");
break;
case 0x08 :
printf ("PHP");
break;
case 0x68 :
printf ("PLA");
break;
case 0x28 :
printf ("PLP");
break;
case 0x2e : case 0x26 : case 0x3e :
case 0x36 :
printf ("ROL");
break;
case 0x2a :
printf ("ROL\tA");
break;
case 0x6e : case 0x66 : case 0x7e :
case 0x76 :
printf ("ROR");
break;
case 0x6a :
printf ("ROR\tA");
break;
case 0x40 :
printf ("RTI");
break;
case 0x60 :
printf ("RTS");
break;
case 0xed : case 0xe5 : case 0xe9 :
case 0xfd : case 0xf9 : case 0xe1 :
case 0xf1 : case 0xf5 :
printf ("SBC");
break;
case 0x38 :
printf ("SEC");
break;
case 0xf8 :
printf ("SED");
break;
case 0x78 :
printf ("SEI");
break;
case 0x8d : case 0x85 : case 0x9d :
case 0x99 : case 0x81 : case 0x91 :
case 0x95 :
printf ("STA");
break;
case 0x8e : case 0x86 : case 0x96 :
printf ("STX");
break;
case 0x8c : case 0x84 : case 0x94 :
printf ("STY");
break;
case 0xaa :
printf ("TAX");
break;
case 0xa8 :
printf ("TAY");
break;
case 0xba :
printf ("TSX");
break;
case 0x8a :
printf ("TXA");
break;
case 0x9a :
printf ("TXS");
break;
case 0x98 :
printf ("TYA");
break;
default :
printf ("*** ILLEGAL INSTRUCTION (%x) ***",instr);
break;
}
}
void show_operand (UBYTE instr)
{
UBYTE byte;
UWORD word;
switch (instr)
{
/*
=========================
Absolute Addressing Modes
=========================
*/
case 0x6d : /* ADC */
case 0x2d : /* AND */
case 0x0e : /* ASL */
case 0x2c : /* BIT */
case 0xcd : /* CMP */
case 0xec : /* CPX */
case 0xcc : /* CPY */
case 0xce : /* DEC */
case 0x4d : /* EOR */
case 0xee : /* INC */
case 0x4c : /* JMP */
case 0x20 : /* JSR */
case 0xaf : /* LAX [unofficial] */
case 0xad : /* LDA */
case 0xae : /* LDX */
case 0xac : /* LDY */
case 0x4e : /* LSR */
case 0x0d : /* ORA */
case 0x2e : /* ROL */
case 0x6e : /* ROR */
case 0xed : /* SBC */
case 0x8d : /* STA */
case 0x8e : /* STX */
case 0x8c : /* STY */
word = (memory[addr+1] << 8) | memory[addr];
printf ("\t$%x",word);
addr += 2;
break;
/*
======================
0-Page Addressing Mode
======================
*/
case 0x65 : /* ADC */
case 0x25 : /* AND */
case 0x06 : /* ASL */
case 0x24 : /* BIT */
case 0xc5 : /* CMP */
case 0xe4 : /* CPX */
case 0xc4 : /* CPY */
case 0xc6 : /* DEC */
case 0x45 : /* EOR */
case 0xe6 : /* INC */
case 0xa7 : /* LAX [unofficial] */
case 0xa5 : /* LDA */
case 0xa6 : /* LDX */
case 0xa4 : /* LDY */
case 0x46 : /* LSR */
case 0x05 : /* ORA */
case 0x26 : /* ROL */
case 0x66 : /* ROR */
case 0xe5 : /* SBC */
case 0x85 : /* STA */
case 0x86 : /* STX */
case 0x84 : /* STY */
byte = memory[addr];
addr++;
printf ("\t$%x",byte);
break;
/*
========================
Relative Addressing Mode
========================
*/
case 0x90 : /* BCC */
case 0xb0 : /* BCS */
case 0xf0 : /* BEQ */
case 0x30 : /* BMI */
case 0xd0 : /* BNE */
case 0x10 : /* BPL */
case 0x50 : /* BVC */
case 0x70 : /* BVS */
byte = memory[addr];
addr++;
printf ("\t$%x",addr+(SBYTE)byte);
break;
/*
=========================
Immediate Addressing Mode
=========================
*/
case 0x69 : /* ADC */
case 0x29 : /* AND */
case 0xc9 : /* CMP */
case 0xe0 : /* CPX */
case 0xc0 : /* CPY */
case 0x49 : /* EOR */
case 0xa9 : /* LDA */
case 0xa2 : /* LDX */
case 0xa0 : /* LDY */
case 0x09 : /* ORA */
case 0xe9 : /* SBC */
case 0xff : /* ESC */
byte = memory[addr];
addr++;
printf ("\t#$%x",byte);
break;
/*
=====================
ABS,X Addressing Mode
=====================
*/
case 0x7d : /* ADC */
case 0x3d : /* AND */
case 0x1e : /* ASL */
case 0xdd : /* CMP */
case 0xde : /* DEC */
case 0x5d : /* EOR */
case 0xfe : /* INC */
case 0xbd : /* LDA */
case 0xbc : /* LDY */
case 0x5e : /* LSR */
case 0x1d : /* ORA */
case 0x3e : /* ROL */
case 0x7e : /* ROR */
case 0xfd : /* SBC */
case 0x9d : /* STA */
word = (memory[addr+1] << 8) | memory[addr];
printf ("\t$%x,X",word);
addr += 2;
break;
/*
=====================
ABS,Y Addressing Mode
=====================
*/
case 0x79 : /* ADC */
case 0x39 : /* AND */
case 0xd9 : /* CMP */
case 0x59 : /* EOR */
case 0xbf : /* LAX [unofficial] */
case 0xb9 : /* LDA */
case 0xbe : /* LDX */
case 0x19 : /* ORA */
case 0xf9 : /* SBC */
case 0x99 : /* STA */
word = (memory[addr+1] << 8) | memory[addr];
printf ("\t$%x,Y",word);
addr += 2;
break;
/*
=======================
(IND,X) Addressing Mode
=======================
*/
case 0x61 : /* ADC */
case 0x21 : /* AND */
case 0xc1 : /* CMP */
case 0x41 : /* EOR */
case 0xa3 : /* LAX [unofficial] */
case 0xa1 : /* LDA */
case 0x01 : /* ORA */
case 0xe1 : /* SBC */
case 0x81 : /* STA */
byte = memory[addr];
addr++;
printf ("\t($%x,X)",byte);
break;
/*
=======================
(IND),Y Addressing Mode
=======================
*/
case 0x71 : /* ADC */
case 0x31 : /* AND */
case 0xd1 : /* CMP */
case 0x51 : /* EOR */
case 0xb3 : /* LAX [unofficial] */
case 0xb1 : /* LDA */
case 0x11 : /* ORA */
case 0xf1 : /* SBC */
case 0x91 : /* STA */
byte = memory[addr];
addr++;
printf ("\t($%x),Y",byte);
break;
/*
========================
0-Page,X Addressing Mode
========================
*/
case 0x75 : /* ADC */
case 0x35 : /* AND */
case 0x16 : /* ASL */
case 0xd5 : /* CMP */
case 0xd6 : /* DEC */
case 0x55 : /* EOR */
case 0xf6 : /* INC */
case 0xb5 : /* LDA */
case 0xb4 : /* LDY */
case 0x56 : /* LSR */
case 0x15 : /* ORA */
case 0x36 : /* ROL */
case 0x76 : /* ROR */
case 0xf5 : /* SBC */
case 0x95 : /* STA */
case 0x94 : /* STY */
byte = memory[addr];
addr++;
printf ("\t$%x,X",byte);
break;
/*
========================
0-Page,Y Addressing Mode
========================
*/
case 0xb7 : /* LAX [unofficial] */
case 0xb6 : /* LDX */
case 0x96 : /* STX */
byte = memory[addr];
addr++;
printf ("\t$%x,Y",byte);
break;
/*
========================
Indirect Addressing Mode
========================
*/
case 0x6c : /* printf ("JMP INDIRECT at %x\n",instr_addr); */
word = (memory[addr+1] << 8) | memory[addr];
printf ("\t($%x)",word);
addr += 2;
break;
}
}