498 lines
13 KiB
C
498 lines
13 KiB
C
|
/* FCE Ultra - NES/Famicom Emulator
|
||
|
|
*
|
||
|
|
* Copyright notice for this file:
|
||
|
|
* Copyright (C) 2003 Xodnizel
|
||
|
|
*
|
||
|
|
* This program is free software; you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU General Public License as published by
|
||
|
|
* the Free Software Foundation; either version 2 of the License, or
|
||
|
|
* (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This program is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License
|
||
|
|
* along with this program; if not, write to the Free Software
|
||
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
#include "fceu-types.h"
|
||
|
|
#include "x6502.h"
|
||
|
|
#include "fceu.h"
|
||
|
|
#include "debug.h"
|
||
|
|
#include "cart.h"
|
||
|
|
|
||
|
|
|
||
|
|
void FCEUI_DumpVid(const char *fname, uint32 start, uint32 end) {
|
||
|
|
FILE *fp = FCEUD_UTF8fopen(fname, "wb");
|
||
|
|
fceuindbg = 1;
|
||
|
|
start &= 0x3FFF;
|
||
|
|
end &= 0x3FFF;
|
||
|
|
for (; start <= end; start++)
|
||
|
|
fputc(VPage[start >> 10][start], fp);
|
||
|
|
fclose(fp);
|
||
|
|
fceuindbg = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FCEUI_DumpMem(const char *fname, uint32 start, uint32 end) {
|
||
|
|
FILE *fp = FCEUD_UTF8fopen(fname, "wb");
|
||
|
|
fceuindbg = 1;
|
||
|
|
for (; start <= end; start++)
|
||
|
|
fputc(ARead[start](start), fp);
|
||
|
|
fclose(fp);
|
||
|
|
fceuindbg = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FCEUI_LoadMem(const char *fname, uint32 start, int hl) {
|
||
|
|
int t;
|
||
|
|
|
||
|
|
FILE *fp = FCEUD_UTF8fopen(fname, "rb");
|
||
|
|
while ((t = fgetc(fp)) >= 0) {
|
||
|
|
if (start > 0xFFFF) break;
|
||
|
|
if (hl) {
|
||
|
|
extern uint8 *Page[32];
|
||
|
|
if (Page[start / 2048])
|
||
|
|
Page[start / 2048][start] = t;
|
||
|
|
} else
|
||
|
|
BWrite[start](start, t);
|
||
|
|
start++;
|
||
|
|
}
|
||
|
|
fclose(fp);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef FCEUDEF_DEBUGGER
|
||
|
|
|
||
|
|
static char *fstrings[12] =
|
||
|
|
{
|
||
|
|
"#$%02X", // immediate
|
||
|
|
"$%04X", // RELATIVE(jump)
|
||
|
|
"$%02X", // Z
|
||
|
|
"$%02X,X", // Z,x
|
||
|
|
"$%02X,Y", // Z,y
|
||
|
|
"$%04X", //ABS
|
||
|
|
"$%04X,X", // ABS,x
|
||
|
|
"$%04X,Y", // ABS,y
|
||
|
|
"($%04X)", // IND
|
||
|
|
"($%02X,X)", // INX
|
||
|
|
"($%02X),Y", // INY
|
||
|
|
""
|
||
|
|
};
|
||
|
|
static int flengths[12] = { 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 0 };
|
||
|
|
|
||
|
|
#define IMD(x) ((0 << 16) | x)
|
||
|
|
#define REL(x) ((1 << 16) | x)
|
||
|
|
#define ZP(x) ((2 << 16) | x)
|
||
|
|
#define ZPX(x) ((3 << 16) | x)
|
||
|
|
#define ZPY(x) ((4 << 16) | x)
|
||
|
|
#define ABS(x) ((5 << 16) | x)
|
||
|
|
#define ABX(x) ((6 << 16) | x)
|
||
|
|
#define ABY(x) ((7 << 16) | x)
|
||
|
|
#define IND(x) ((8 << 16) | x)
|
||
|
|
#define INX(x) ((9 << 16) | x)
|
||
|
|
#define INY(x) ((10 << 16) | x)
|
||
|
|
#define IMP(x) ((11 << 16) | x)
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
char *name;
|
||
|
|
int type; /* 1 for read, 2 for write, 3 for r then write. */
|
||
|
|
int32 modes[10];
|
||
|
|
} OPS;
|
||
|
|
#define NUMOPS 56
|
||
|
|
static OPS optable[NUMOPS] =
|
||
|
|
{
|
||
|
|
{ "BRK", 0, { IMP(0x00), -1 } },
|
||
|
|
{ "RTI", 0, { IMP(0x40), -1 } },
|
||
|
|
{ "RTS", 0, { IMP(0x60), -1 } },
|
||
|
|
{ "PHA", 2, { IMP(0x48), -1 } },
|
||
|
|
{ "PHP", 2, { IMP(0x08), -1 } },
|
||
|
|
{ "PLA", 1, { IMP(0x68), -1 } },
|
||
|
|
{ "PLP", 1, { IMP(0x28), -1 } },
|
||
|
|
{ "JMP", 0, { ABS(0x4C), IND(0x6C), -1 } },
|
||
|
|
{ "JSR", 0, { ABS(0x20), -1 } },
|
||
|
|
{ "TAX", 0, { IMP(0xAA), -1 } },
|
||
|
|
{ "TXA", 0, { IMP(0x8A), -1 } },
|
||
|
|
{ "TAY", 0, { IMP(0xA8), -1 } },
|
||
|
|
{ "TYA", 0, { IMP(0x98), -1 } },
|
||
|
|
{ "TSX", 0, { IMP(0xBA), -1 } },
|
||
|
|
{ "TXS", 0, { IMP(0x9A), -1 } },
|
||
|
|
{ "DEX", 0, { IMP(0xCA), -1 } },
|
||
|
|
{ "DEY", 0, { IMP(0x88), -1 } },
|
||
|
|
{ "INX", 0, { IMP(0xE8), -1 } },
|
||
|
|
{ "INY", 0, { IMP(0xC8), -1 } },
|
||
|
|
{ "CLC", 0, { IMP(0x18), -1 } },
|
||
|
|
{ "CLD", 0, { IMP(0xD8), -1 } },
|
||
|
|
{ "CLI", 0, { IMP(0x58), -1 } },
|
||
|
|
{ "CLV", 0, { IMP(0xB8), -1 } },
|
||
|
|
{ "SEC", 0, { IMP(0x38), -1 } },
|
||
|
|
{ "SED", 0, { IMP(0xF8), -1 } },
|
||
|
|
{ "SEI", 0, { IMP(0x78), -1 } },
|
||
|
|
{ "NOP", 0, { IMP(0xEA), -1 } },
|
||
|
|
{ "ASL", 1, { IMP(0x0a), ZP(0x06), ZPX(0x16), ABS(0x0E), ABX(0x1E), -1 } },
|
||
|
|
{ "DEC", 3, { ZP(0xc6), ZPX(0xd6), ABS(0xcE), ABX(0xdE), -1 } },
|
||
|
|
{ "INC", 3, { ZP(0xe6), ZPX(0xf6), ABS(0xeE), ABX(0xfE), -1 } },
|
||
|
|
{ "LSR", 3, { IMP(0x4a), ZP(0x46), ZPX(0x56), ABS(0x4E), ABX(0x5E), -1 } },
|
||
|
|
{ "ROL", 3, { IMP(0x2a), ZP(0x26), ZPX(0x36), ABS(0x2E), ABX(0x3E), -1 } },
|
||
|
|
{ "ROR", 3, { IMP(0x6a), ZP(0x66), ZPX(0x76), ABS(0x6E), ABX(0x7E), -1 } },
|
||
|
|
{ "ADC", 1, { IMD(0x69), ZP(0x65), ZPX(0x75), ABS(0x6D), ABX(0x7d), ABY(0x79),
|
||
|
|
INX(0x61), INY(0x71), -1 } },
|
||
|
|
{ "AND", 1, { IMD(0x29), ZP(0x25), ZPX(0x35), ABS(0x2D), ABX(0x3d), ABY(0x39),
|
||
|
|
INX(0x21), INY(0x31), -1 } },
|
||
|
|
{ "BIT", 1, { ZP(0x24), ABS(0x2c), -1 } },
|
||
|
|
{ "CMP", 1, { IMD(0xc9), ZP(0xc5), ZPX(0xd5), ABS(0xcD), ABX(0xdd), ABY(0xd9),
|
||
|
|
INX(0xc1), INY(0xd1), -1 } },
|
||
|
|
{ "CPX", 1, { IMD(0xe0), ZP(0xe4), ABS(0xec), -1 } },
|
||
|
|
{ "CPY", 1, { IMD(0xc0), ZP(0xc4), ABS(0xcc), -1 } },
|
||
|
|
{ "EOR", 1, { IMD(0x49), ZP(0x45), ZPX(0x55), ABS(0x4D), ABX(0x5d), ABY(0x59),
|
||
|
|
INX(0x41), INY(0x51), -1 } },
|
||
|
|
{ "LDA", 1, { IMD(0xa9), ZP(0xa5), ZPX(0xb5), ABS(0xaD), ABX(0xbd), ABY(0xb9),
|
||
|
|
INX(0xa1), INY(0xb1), -1 } },
|
||
|
|
{ "LDX", 1, { IMD(0xa2), ZP(0xa6), ZPY(0xB6), ABS(0xae), ABY(0xbe), -1 } },
|
||
|
|
{ "LDY", 1, { IMD(0xa0), ZP(0xa4), ZPX(0xB4), ABS(0xac), ABX(0xbc), -1 } },
|
||
|
|
{ "ORA", 1, { IMD(0x09), ZP(0x05), ZPX(0x15), ABS(0x0D), ABX(0x1d), ABY(0x19),
|
||
|
|
INX(0x01), INY(0x11), -1 } },
|
||
|
|
{ "SBC", 1, { IMD(0xEB), IMD(0xe9), ZP(0xe5), ZPX(0xf5), ABS(0xeD), ABX(0xfd), ABY(0xf9),
|
||
|
|
INX(0xe1), INY(0xf1), -1 } },
|
||
|
|
{ "STA", 2, { ZP(0x85), ZPX(0x95), ABS(0x8D), ABX(0x9d), ABY(0x99),
|
||
|
|
INX(0x81), INY(0x91), -1 } },
|
||
|
|
{ "STX", 2, { ZP(0x86), ZPY(0x96), ABS(0x8E), -1 } },
|
||
|
|
{ "STY", 2, { ZP(0x84), ZPX(0x94), ABS(0x8C), -1 } },
|
||
|
|
{ "BCC", 1, { REL(0x90), -1 } },
|
||
|
|
{ "BCS", 1, { REL(0xb0), -1 } },
|
||
|
|
{ "BEQ", 1, { REL(0xf0), -1 } },
|
||
|
|
{ "BNE", 1, { REL(0xd0), -1 } },
|
||
|
|
{ "BMI", 1, { REL(0x30), -1 } },
|
||
|
|
{ "BPL", 1, { REL(0x10), -1 } },
|
||
|
|
{ "BVC", 1, { REL(0x50), -1 } },
|
||
|
|
{ "BVS", 1, { REL(0x70), -1 } },
|
||
|
|
};
|
||
|
|
|
||
|
|
uint16 FCEUI_Disassemble(void *XA, uint16 a, char *stringo) {
|
||
|
|
X6502 *X = XA;
|
||
|
|
uint8 buf;
|
||
|
|
uint32 arg;
|
||
|
|
int32 info;
|
||
|
|
int x;
|
||
|
|
int y;
|
||
|
|
|
||
|
|
info = -1;
|
||
|
|
fceuindbg = 1;
|
||
|
|
|
||
|
|
buf = ARead[a](a);
|
||
|
|
a++;
|
||
|
|
|
||
|
|
for (x = 0; x < NUMOPS; x++) {
|
||
|
|
y = 0;
|
||
|
|
while (optable[x].modes[y] >= 0) {
|
||
|
|
if ((optable[x].modes[y] & 0xFF) == buf) {
|
||
|
|
info = optable[x].modes[y];
|
||
|
|
goto endy;
|
||
|
|
}
|
||
|
|
y++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
endy:
|
||
|
|
sprintf(stringo, "%02X ", buf);
|
||
|
|
if (info >= 0) {
|
||
|
|
int z = flengths[(info >> 16)];
|
||
|
|
|
||
|
|
if (z) {
|
||
|
|
arg = ARead[a](a);
|
||
|
|
sprintf(stringo + strlen(stringo), "%02X ", arg);
|
||
|
|
a++;
|
||
|
|
if (z == 2) {
|
||
|
|
arg |= ARead[a](a) << 8; sprintf(stringo + strlen(stringo), "%02X ", arg >> 8); a++;
|
||
|
|
} else
|
||
|
|
strcat(stringo, " ");
|
||
|
|
|
||
|
|
if ((info >> 16) == 1) /* Relative branch */
|
||
|
|
arg = a + (char)arg;
|
||
|
|
sprintf(stringo + strlen(stringo), "%s ", optable[x].name);
|
||
|
|
sprintf(stringo + strlen(stringo), fstrings[info >> 16], arg);
|
||
|
|
/*
|
||
|
|
0 "#$%02X", // immediate
|
||
|
|
1 "$%04X", // RELATIVE(jump)
|
||
|
|
2 "$%02X", // Z
|
||
|
|
3 "$%02X,X", // Z,x
|
||
|
|
4 "$%02X,Y", // Z,y
|
||
|
|
5 "$%04X", //ABS
|
||
|
|
6 "$%04X,X", // ABS,x
|
||
|
|
7 "$%04X,Y", // ABS,y
|
||
|
|
8 "($%04X)", // IND
|
||
|
|
9 "($%02X,X)", // INX
|
||
|
|
10 "($%02X),Y", // INY
|
||
|
|
11 #define IMP(x) ((11<<16)|x)
|
||
|
|
*/
|
||
|
|
{
|
||
|
|
uint32 tmp;
|
||
|
|
switch (info >> 16) {
|
||
|
|
case 2: tmp = arg;
|
||
|
|
if (optable[x].type & 1) {
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3: tmp = (arg + X->X) & 0xff;
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
case 4: tmp = (arg + X->Y) & 0xff;
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
case 5: tmp = arg;
|
||
|
|
if (optable[x].type & 1) {
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 6: tmp = (arg + X->X) & 0xffff;
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
case 7: tmp = (arg + X->Y) & 0xffff;
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
case 8: tmp = ARead[arg](arg) | (ARead[(arg + 1) & 0xffff]((arg + 1) & 0xffff) << 8);
|
||
|
|
sprintf(stringo + strlen(stringo), " $%04X", tmp);
|
||
|
|
break;
|
||
|
|
case 9: tmp = (arg + X->X) & 0xFF;
|
||
|
|
tmp = ARead[tmp](tmp) | (ARead[(tmp + 1) & 0xFF]((tmp + 1) & 0xFF) << 8);
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
case 10: tmp = ARead[arg](arg) | (ARead[(arg + 1) & 0xFF]((arg + 1) & 0xFF) << 8);
|
||
|
|
tmp = (tmp + X->Y) & 0xFFFF;
|
||
|
|
sprintf(stringo + strlen(stringo), " @ $%04X", tmp);
|
||
|
|
if (optable[x].type & 1)
|
||
|
|
sprintf(stringo + strlen(stringo), " = $%02X", ARead[tmp](tmp));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
strcat(stringo, " ");
|
||
|
|
strcat(stringo, optable[x].name);
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
sprintf(stringo + strlen(stringo), " .db $%02X", buf);
|
||
|
|
fceuindbg = 0;
|
||
|
|
return(a);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FCEUI_MemDump(uint16 a, int32 len, void (*callb)(uint16 a, uint8 v)) {
|
||
|
|
fceuindbg = 1;
|
||
|
|
while (len) {
|
||
|
|
callb(a, ARead[a](a));
|
||
|
|
a++;
|
||
|
|
len--;
|
||
|
|
}
|
||
|
|
fceuindbg = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8 FCEUI_MemSafePeek(uint16 A) {
|
||
|
|
uint8 ret;
|
||
|
|
|
||
|
|
fceuindbg = 1;
|
||
|
|
ret = ARead[A](A);
|
||
|
|
fceuindbg = 0;
|
||
|
|
return(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FCEUI_MemPoke(uint16 a, uint8 v, int hl) {
|
||
|
|
extern uint8 *Page[32];
|
||
|
|
if (hl) {
|
||
|
|
if (Page[a / 2048])
|
||
|
|
Page[a / 2048][a] = v;
|
||
|
|
} else
|
||
|
|
BWrite[a](a, v);
|
||
|
|
}
|
||
|
|
|
||
|
|
typedef struct __BPOINT {
|
||
|
|
struct __BPOINT *next;
|
||
|
|
void (*Handler)(X6502 *X, int type, uint32 A);
|
||
|
|
uint32 A[2];
|
||
|
|
int type;
|
||
|
|
} BPOINT;
|
||
|
|
|
||
|
|
static BPOINT *BreakPoints = NULL;
|
||
|
|
static BPOINT *LastBP = NULL;
|
||
|
|
|
||
|
|
static void (*CPUHook)(X6502 *) = NULL;
|
||
|
|
|
||
|
|
static int FindBPoint(X6502 *X, int who, uint32 A) {
|
||
|
|
BPOINT *tmp;
|
||
|
|
|
||
|
|
tmp = BreakPoints;
|
||
|
|
while (tmp) {
|
||
|
|
if (who & BPOINT_EXCLUDE) {
|
||
|
|
if ((tmp->type & who) == who) {
|
||
|
|
if ((X->PC >= tmp->A[0]) && (X->PC <= tmp->A[1])) {
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (tmp->type & who) {
|
||
|
|
if (tmp->type & BPOINT_PC)
|
||
|
|
if (X->PC != A) goto don;
|
||
|
|
if (tmp->type & BPOINT_EXCLUDE) goto don;
|
||
|
|
|
||
|
|
if ((A >= tmp->A[0]) && (A <= tmp->A[1])) {
|
||
|
|
if (!FindBPoint(X, who | BPOINT_EXCLUDE, A)) {
|
||
|
|
tmp->Handler(X, tmp->type, A);
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
don:
|
||
|
|
tmp = tmp->next;
|
||
|
|
}
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8 ReadHandler(X6502 *X, uint32 A) {
|
||
|
|
extern X6502 XSave;
|
||
|
|
|
||
|
|
if (X->preexec)
|
||
|
|
FindBPoint(&XSave, BPOINT_READ, A);
|
||
|
|
return(ARead[A](A));
|
||
|
|
}
|
||
|
|
|
||
|
|
static void WriteHandler(X6502 *X, uint32 A, uint8 V) {
|
||
|
|
extern X6502 XSave;
|
||
|
|
|
||
|
|
if (X->preexec)
|
||
|
|
FindBPoint(&XSave, BPOINT_WRITE, A);
|
||
|
|
else
|
||
|
|
BWrite[A](A, V);
|
||
|
|
}
|
||
|
|
|
||
|
|
int FCEUI_AddBreakPoint(int type, uint32 A1, uint32 A2,
|
||
|
|
void (*Handler)(X6502 *, int type, uint32 A)) {
|
||
|
|
BPOINT *tmp;
|
||
|
|
|
||
|
|
tmp = (BPOINT*)malloc(sizeof(BPOINT));
|
||
|
|
|
||
|
|
tmp->A[0] = A1;
|
||
|
|
tmp->A[1] = A2;
|
||
|
|
tmp->Handler = Handler;
|
||
|
|
tmp->type = type;
|
||
|
|
tmp->next = 0;
|
||
|
|
|
||
|
|
if (BreakPoints == NULL)
|
||
|
|
BreakPoints = tmp;
|
||
|
|
else
|
||
|
|
LastBP->next = tmp;
|
||
|
|
|
||
|
|
LastBP = tmp;
|
||
|
|
|
||
|
|
X6502_Debug(CPUHook, ReadHandler, WriteHandler);
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
int FCEUI_SetBreakPoint(uint32 w, int type, uint32 A1, uint32 A2,
|
||
|
|
void (*Handler)(X6502 *, int type, uint32 A)) {
|
||
|
|
uint32 x = 0;
|
||
|
|
BPOINT *tmp;
|
||
|
|
|
||
|
|
tmp = BreakPoints;
|
||
|
|
|
||
|
|
while (tmp) {
|
||
|
|
if (w == x) {
|
||
|
|
tmp->type = type;
|
||
|
|
tmp->A[0] = A1;
|
||
|
|
tmp->A[1] = A2;
|
||
|
|
tmp->Handler = Handler;
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
x++;
|
||
|
|
tmp = tmp->next;
|
||
|
|
}
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
int FCEUI_GetBreakPoint(uint32 w, int *type, uint32 *A1, uint32 *A2,
|
||
|
|
void(**Handler) (X6502 *, int type, uint32 A)) {
|
||
|
|
uint32 x = 0;
|
||
|
|
BPOINT *tmp;
|
||
|
|
|
||
|
|
tmp = BreakPoints;
|
||
|
|
|
||
|
|
while (tmp) {
|
||
|
|
if (w == x) {
|
||
|
|
*type = tmp->type;
|
||
|
|
*A1 = tmp->A[0];
|
||
|
|
*A2 = tmp->A[1];
|
||
|
|
*Handler = tmp->Handler;
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
x++;
|
||
|
|
tmp = tmp->next;
|
||
|
|
}
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
int FCEUI_ListBreakPoints(int (*callb)(int type, uint32 A1, uint32 A2,
|
||
|
|
void (*Handler)(X6502 *, int type, uint32 A))) {
|
||
|
|
BPOINT *tmp;
|
||
|
|
tmp = BreakPoints;
|
||
|
|
while (tmp) {
|
||
|
|
callb(tmp->type, tmp->A[0], tmp->A[1], tmp->Handler);
|
||
|
|
tmp = tmp->next;
|
||
|
|
}
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
int FCEUI_DeleteBreakPoint(uint32 w) {
|
||
|
|
BPOINT *tmp, *prev = NULL;
|
||
|
|
uint32 x = 0;
|
||
|
|
|
||
|
|
tmp = BreakPoints;
|
||
|
|
|
||
|
|
while (tmp) {
|
||
|
|
if (w == x) {
|
||
|
|
if (prev) { /* Not the first breakpoint. */
|
||
|
|
if (tmp->next) /* More breakpoints. */
|
||
|
|
prev->next = tmp->next;
|
||
|
|
else { /* This is the last breakpoint. */
|
||
|
|
prev->next = 0;
|
||
|
|
LastBP = prev;
|
||
|
|
}
|
||
|
|
} else {/* The first breakpoint. */
|
||
|
|
if (tmp->next) /* More breakpoints. */
|
||
|
|
BreakPoints = tmp->next;
|
||
|
|
else {
|
||
|
|
BreakPoints = LastBP = 0; /* No more breakpoints. */
|
||
|
|
/* Update the CPU hooks. */
|
||
|
|
X6502_Debug(CPUHook, BreakPoints ? ReadHandler : 0, BreakPoints ? WriteHandler : 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
free(tmp);
|
||
|
|
tmp = 0;
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
prev = tmp;
|
||
|
|
tmp = tmp->next;
|
||
|
|
x++;
|
||
|
|
}
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FCEUI_SetCPUCallback(void (*callb)(X6502 *X)) {
|
||
|
|
CPUHook = callb;
|
||
|
|
X6502_Debug(CPUHook, BreakPoints ? ReadHandler : 0, BreakPoints ? WriteHandler : 0);
|
||
|
|
}
|
||
|
|
#endif
|