static struct device_functions *device_func[2];
static int have_ioctl;
-#ifdef WIN32
+#ifdef _WIN32
#include "od-win32/win32.h"
}
return device_func[DF_IOCTL]->read (unitnum, offset);
}
+uae_u8 *sys_command_cd_rawread (int mode, int unitnum, int offset, int size)
+{
+ if (mode == DF_SCSI || !have_ioctl) {
+ uae_u8 cmd[12] = { 0xbe, 0, 0, 0, 0, 0, 0, 0, 1, 0x10, 0, 0 };
+ cmd[3] = (uae_u8)(offset >> 16);
+ cmd[4] = (uae_u8)(offset >> 8);
+ cmd[5] = (uae_u8)(offset >> 0);
+ return device_func[DF_SCSI]->exec_in (unitnum, cmd, sizeof (cmd), 0);
+ }
+ return device_func[DF_IOCTL]->rawread (unitnum, offset, size);
+}
/* read block */
uae_u8 *sys_command_read (int mode, int unitnum, int offset)
*/
//#define CDTV_DEBUG
-//#define CDTV_DEBUG_CMD
+#define CDTV_DEBUG_CMD
//#define CDTV_DEBUG_6525
#include "sysconfig.h"
static volatile int cdrom_sector, cdrom_sectors, cdrom_length, cdrom_offset;
static volatile int cd_playing, cd_paused, cd_motor, cd_media, cd_error, cd_finished, cd_isready, cd_hunt;
-static volatile int cdtv_hsync, dma_finished;
+static volatile int cdtv_hsync, dma_finished, cdtv_sectorsize;
static volatile uae_u64 dma_wait;
static void do_stch(void);
if (!s)
return 0;
memcpy (cdrom_qcode, s, 16);
- if (cd_playing && s[1] == 0x11) {
- int end = msf2lsn((s[5 + 4] << 16) | (s[6 + 4] << 8) | (s[7 + 4]));
- if (end >= play_end) {
- sys_command_cd_pause (DF_IOCTL, unitnum, 1);
+ if (cd_playing) {
+ if (s[1] == AUDIO_STATUS_IN_PROGRESS) {
+ int end = msf2lsn((s[5 + 4] << 16) | (s[6 + 4] << 8) | (s[7 + 4]));
+ if (end >= play_end - 75) {
+ sys_command_cd_pause (DF_IOCTL, unitnum, 1);
+ cd_audio_status = AUDIO_STATUS_PLAY_COMPLETE;
+ cd_playing = 0;
+ do_stch();
+ }
+ } else if (s[1] == AUDIO_STATUS_PLAY_COMPLETE) {
cd_audio_status = AUDIO_STATUS_PLAY_COMPLETE;
cd_playing = 0;
do_stch();
static int read_sectors(int start, int length)
{
- write_log("READ DATA sector %d, %d sectors\n", start, length);
+ write_log("READ DATA sector %d, %d sectors (blocksize=%d)\n", start, length, cdtv_sectorsize);
cdrom_sector = start;
cdrom_sectors = length;
- cdrom_offset = start * 2048;
- cdrom_length = length * 2048;
+ cdrom_offset = start * cdtv_sectorsize;
+ cdrom_length = length * cdtv_sectorsize;
cd_motor = 1;
cd_audio_status = AUDIO_STATUS_NOT_SUPPORTED;
if (cd_playing)
start = (p[1] << 16) | (p[2] << 8) | p[3];
end = (p[4] << 16) | (p[5] << 8) | p[6];
+ if (p[0] == 0x09) /* end is length in lsn-mode */
+ end += start;
if (start == 0 && end == 0) {
cd_finished = 0;
if (cd_playing)
cd_audio_status = AUDIO_STATUS_PLAY_COMPLETE;
sys_command_cd_pause (DF_IOCTL, unitnum, 0);
sys_command_cd_stop (DF_IOCTL, unitnum);
- cd_isready = 10;
+ cd_isready = 50;
return 0;
}
- if (end == 0x00ffffff)
- end = last_cd_position;
- if (p[0] == 0x09) {
+ if (p[0] == 0x09) { /* lsn */
start = lsn2msf (start);
- end = lsn2msf (end);
+ if (end < 0x00ffffff)
+ end = lsn2msf (end);
}
+ if (end == 0x00ffffff || end > last_cd_position)
+ end = last_cd_position;
play_end = msf2lsn(end);
play_start = msf2lsn(start);
write_log("PLAY CD AUDIO from %06.6X (%d) to %06.6X (%d)\n",
return -1;
}
+static int cdrom_modeset(uae_u8 *cmd)
+{
+ cdtv_sectorsize = (cmd[2] << 8) | cmd[3];
+ if (cdtv_sectorsize != 2048 && cdtv_sectorsize != 2336) {
+ write_log("CDTV: tried to set unknown sector size %d\n", cdtv_sectorsize);
+ cdtv_sectorsize = 2048;
+ }
+ return 0;
+}
+
static void cdrom_command_accepted(int size, uae_u8 *cdrom_command_input, int *cdrom_command_cnt_in)
{
#ifdef CDTV_DEBUG_CMD
break;
case 0x84:
if (cdrom_command_cnt_in == 7) {
- cdrom_command_accepted(0, s, &cdrom_command_cnt_in);
+ cdrom_command_accepted(cdrom_modeset(cdrom_command_input), s, &cdrom_command_cnt_in);
cd_finished = 1;
}
break;
#define ISTR_INT_P (1 << 4)
#define ISTR_E_INT (1 << 5)
+extern uae_u8 *ioctl_command_rawread (int unitnum, int sector);
+
static void dma_do_thread(void)
{
static int readsector;
uae_u8 *p = NULL;
- //write_log("DMAC DMA: sector=%d, addr=%08.8X, words=%d\n",
- //cdrom_offset / 2048, dmac_acr, dmac_wtc);
+ write_log("DMAC DMA: sector=%d, addr=%08.8X, words=%d\n", cdrom_offset / cdtv_sectorsize, dmac_acr, dmac_wtc);
dma_wait += dmac_wtc * (uae_u64)312 * 50 / 75 + 1;
while (dmac_wtc > 0 && dmac_dma) {
- if (!p || readsector != (cdrom_offset / 2048)) {
- readsector = cdrom_offset / 2048;
- p = sys_command_cd_read (DF_IOCTL, unitnum, readsector);
+ if (!p || readsector != (cdrom_offset / cdtv_sectorsize)) {
+ readsector = cdrom_offset / cdtv_sectorsize;
+ if (cdtv_sectorsize == 2336)
+ p = sys_command_cd_rawread (DF_IOCTL, unitnum, readsector, cdtv_sectorsize);
+ else
+ p = sys_command_cd_read (DF_IOCTL, unitnum, readsector);
if (!p) {
cd_error = 1;
activate_stch = 1;
}
}
- put_byte (dmac_acr, p[(cdrom_offset % 2048) + 0]);
- put_byte (dmac_acr + 1, p[(cdrom_offset % 2048) + 1]);
+ put_byte (dmac_acr, p[(cdrom_offset % cdtv_sectorsize) + 0]);
+ put_byte (dmac_acr + 1, p[(cdrom_offset % cdtv_sectorsize) + 1]);
dmac_wtc--;
dmac_acr+=2;
cdrom_length-=2;
ciaata -= ciaclocks;
}
if ((ciaacrb & 0x61) == 0x01) {
- assert ((ciaatb+1) >= ciaclocks);
- if ((ciaatb+1) == ciaclocks) aovflb = 1;
+ assert ((ciaatb + 1) >= ciaclocks);
+ if ((ciaatb + 1) == ciaclocks) aovflb = 1;
ciaatb -= ciaclocks;
}
ciabta -= ciaclocks;
}
if ((ciabcrb & 0x61) == 0x01) {
- assert ((ciabtb+1) >= ciaclocks);
- if ((ciabtb+1) == ciaclocks) bovflb = 1;
+ assert ((ciabtb + 1) >= ciaclocks);
+ if ((ciabtb + 1) == ciaclocks) bovflb = 1;
ciabtb -= ciaclocks;
}
tmp = arcadia_parport (0, ciaaprb, ciaadrb);
#endif
} else {
- tmp = handle_parport_joystick (0, ciaaprb, ciaadrb);
- }
#else
- tmp = handle_parport_joystick (0, ciaaprb, ciaadrb);
-#ifdef DONGLE_DEBUG
- if (notinrom())
- write_log ("BFE101 R %02.2X %s\n", tmp, debuginfo(0));
+ {
#endif
+ tmp = handle_parport_joystick (0, ciaaprb, ciaadrb);
+#ifdef DONGLE_DEBUG
+ if (notinrom())
+ write_log ("BFE101 R %02.2X %s\n", tmp, debuginfo(0));
#endif
+ }
if (ciaacrb & 2) {
int pb7 = 0;
if (ciaacrb & 4)
save_u8 (b);
t = (num ? ciabta - ciabta_passed : ciaata - ciaata_passed);/* 4 TA */
save_u16 (t);
- t = (num ? ciabtb - ciabtb_passed : ciaatb - ciaatb_passed);/* 8 TB */
+ t = (num ? ciabtb - ciabtb_passed : ciaatb - ciaatb_passed);/* 6 TB */
save_u16 (t);
b = (num ? ciabtod : ciaatod); /* 8 TODL */
save_u8 (b);
" s <string>/<values> [<addr>] [<length>]\n"
" Search for string/bytes\n"
" T Show exec tasks and their PCs\n"
- " h,? Show this help page\n"
" b Step to previous state capture position\n"
" am <channel mask> Enable or disable audio channels\n"
" sm <sprite mask> Enable or disable sprites\n"
" di <mode> [<track>] Break on disk access. R=DMA read,W=write,RW=both,P=PIO\n"
- " Also enables extended disk logging\n"
+ " Also enables level 1 disk logging\n"
+ " did <log level> Enable disk logging\n"
" dj [<level bitmask>] Enable joystick/mouse input debugging\n"
" dm Dump current address space map\n"
-#ifdef WIN32
+#ifdef _WIN32
" x Close debugger.\n"
" xx Switch between console and GUI debugger.\n"
#endif
first = 0;
}
-#define BREAKPOINT_TOTAL 8
-struct breakpoint_node {
- uaecptr addr;
- int enabled;
-};
-static struct breakpoint_node bpnodes[BREAKPOINT_TOTAL];
-
+struct breakpoint_node bpnodes[BREAKPOINT_TOTAL];
static addrbank **debug_mem_banks;
static addrbank *debug_mem_area;
-#define MEMWATCH_TOTAL 8
-struct memwatch_node {
- uaecptr addr;
- int size;
- int rwi;
- uae_u32 val;
- int val_enabled;
- uae_u32 modval;
- int modval_written;
- int frozen;
-};
-static struct memwatch_node mwnodes[MEMWATCH_TOTAL];
+struct memwatch_node mwnodes[MEMWATCH_TOTAL];
static struct memwatch_node mwhit;
static uae_u8 *illgdebug;
memwatch_enabled = 1;
}
-static void memwatch_dump (int num)
+void memwatch_dump2 (char *buf, int bufsize, int num)
{
int i;
struct memwatch_node *mwn;
+
+ if (buf)
+ memset(buf, 0, bufsize);
for (i = 0; i < MEMWATCH_TOTAL; i++) {
if ((num >= 0 && num == i) || (num < 0)) {
mwn = &mwnodes[i];
if (mwn->size == 0)
continue;
- console_out ("%d: %08.8X - %08.8X (%d) %c%c%c",
+ buf = buf_out (buf, &bufsize, "%d: %08.8X - %08.8X (%d) %c%c%c",
i, mwn->addr, mwn->addr + (mwn->size - 1), mwn->size,
(mwn->rwi & 1) ? 'R' : ' ', (mwn->rwi & 2) ? 'W' : ' ', (mwn->rwi & 4) ? 'I' : ' ');
if (mwn->frozen)
- console_out ("F");
+ buf = buf_out (buf, &bufsize, "F");
if (mwn->val_enabled)
- console_out (" =%X", mwn->val);
+ buf = buf_out (buf, &bufsize, " =%X", mwn->val);
if (mwn->modval_written)
- console_out (" =M");
- console_out("\n");
+ buf = buf_out (buf, &bufsize, " =M");
+ buf = buf_out (buf, &bufsize, "\n");
}
}
}
+static void memwatch_dump (int num)
+{
+ char *buf;
+ int multiplier = num < 0 ? MEMWATCH_TOTAL : 1;
+
+ buf = malloc(50 * multiplier);
+ if (!buf)
+ return;
+ memwatch_dump2 (buf, 50 * multiplier, num);
+ f_out(stdout, "%s", buf);
+ free(buf);
+}
+
static void memwatch (char **c)
{
int num;
char parm[10];
int i;
- disk_debug_logging = 2;
+ if (**inptr == 'd') {
+ (*inptr)++;
+ ignore_ws(inptr);
+ disk_debug_logging = readint(inptr);
+ console_out("disk logging level %d\n", disk_debug_logging);
+ return;
+ }
disk_debug_mode = 0;
disk_debug_track = -1;
ignore_ws(inptr);
disk_debug_track = readint(inptr);
if (disk_debug_track < 0 || disk_debug_track > 2 * 83)
disk_debug_track = -1;
+ if (disk_debug_logging == 0)
+ disk_debug_logging = 1;
end:
console_out("disk breakpoint mode %c%c%c track %d\n",
disk_debug_mode & DISK_DEBUG_DMA_READ ? 'R' : '-',
static void addhistory(void)
{
+ uae_u32 pc = m68k_getpc(®s);
+ if (pc >= 0xf00000 && pc <= 0xffffff)
+ return;
history[lasthist] = regs;
history[lasthist].pc = m68k_getpc(®s);
if (++lasthist == MAX_HIST)
int notinrom (void)
{
- if (munge24 (m68k_getpc(®s)) < 0xe0000)
+ if (munge24 (m68k_getpc(®s)) < 0x00e00000)
return 1;
return 0;
}
-/*
+
const char *debuginfo (int mode)
{
static char txt[100];
- uae_u32 pc = m68k_getpc();
+ uae_u32 pc = M68K_GETPC;
sprintf (txt, "PC=%08.8X INS=%04.4X %04.4X %04.4X",
pc, get_word(pc), get_word(pc+2), get_word(pc+4));
return txt;
}
-*/
static int mmu_logging;
{
drive *drv;
int state, dfxtype;
+ char old[MAX_DPATH];
+ int newis;
drv = &floppy[num];
disabled &= ~(1 << num);
drv->dskchange = 0;
drv->dskchange_time = 0;
restore_u32 ();
+ strcpy (old, currprefs.df[num]);
strncpy(changed_prefs.df[num],src,255);
+ newis = changed_prefs.df[num][0] ? 1 : 0;
src+=strlen(src)+1;
drive_insert (floppy + num, &currprefs, num, changed_prefs.df[num]);
- if (drive_empty (floppy + num))
- drv->dskchange = 1;
-
+ if (drive_empty (floppy + num)) {
+ if (newis && old[0]) {
+ strcpy (changed_prefs.df[num], old);
+ drive_insert (floppy + num, &currprefs, num, changed_prefs.df[num]);
+ if (drive_empty (floppy + num))
+ drv->dskchange = 1;
+ }
+ }
return src;
}
| (m68k_dreg (regs, reg) & ~0xff)));
break;
case 4:
- m68k_dreg (regs, reg) = (uae_u32)(((toint(value, -32768.0, 327676.0) & 0xffff)
+ m68k_dreg (regs, reg) = (uae_u32)(((toint(value, -32768.0, 32767.0) & 0xffff)
| (m68k_dreg (regs, reg) & ~0xffff)));
break;
case 0:
typedef uae_u8* (*qcode_func)(int);
typedef uae_u8* (*toc_func)(int);
typedef uae_u8* (*read_func)(int, int);
+typedef uae_u8* (*rawread_func)(int, int, int);
typedef int (*write_func)(int, int);
typedef int (*isatapi_func)(int);
typedef int (*ismedia_func)(int, int);
qcode_func qcode;
toc_func toc;
read_func read;
+ rawread_func rawread;
write_func write;
isatapi_func isatapi;
extern uae_u8 *sys_command_cd_qcode (int mode, int unitnum);
extern uae_u8 *sys_command_cd_toc (int mode, int unitnum);
extern uae_u8 *sys_command_cd_read (int mode, int unitnum, int offset);
+extern uae_u8 *sys_command_cd_rawread (int mode, int unitnum, int offset, int size);
extern uae_u8 *sys_command_read (int mode, int unitnum, int offset);
extern int sys_command_write (int mode, int unitnum, int offset);
extern int sys_command_scsi_direct (int unitnum, uaecptr request);
extern void debug_help (void);
extern uaecptr dumpmem2 (uaecptr addr, char *out, int osize);
extern void update_debug_info (void);
+
+#define BREAKPOINT_TOTAL 8
+struct breakpoint_node {
+ uaecptr addr;
+ int enabled;
+};
+extern struct breakpoint_node bpnodes[BREAKPOINT_TOTAL];
+
+#define MEMWATCH_TOTAL 8
+struct memwatch_node {
+ uaecptr addr;
+ int size;
+ int rwi;
+ uae_u32 val;
+ int val_enabled;
+ uae_u32 modval;
+ int modval_written;
+ int frozen;
+};
+extern struct memwatch_node mwnodes[MEMWATCH_TOTAL];
+
+extern void memwatch_dump2 (char *buf, int bufsize, int num);
+
#else
STATIC_INLINE void activate_debugger (void) { };
#else
#define flush_icache(X) do {} while (0)
#endif
+
+extern int movec_illg (int regno);
+extern uae_u32 val_move2c (int regno);
+struct cpum2c {
+ int regno;
+ char *regname;
+};
+extern struct cpum2c m2cregs[];
\ No newline at end of file
#ifndef CPUEMU_68000_ONLY
-static int movec_illg (int regno)
+int movec_illg (int regno)
{
int regno2 = regno & 0x7ff;
*nextpc = m68k_getpc (®s) + m68kpc_offset;
}
-static int m2cregn[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 0x800, 0x801, 0x802, 0x803, 0x804, 0x805, 0x806, 0x807, 0x808, -1 };
-static char *m2cregs[] = { "SFC ", "DFC ", "CACR", "TC ", "ITT0", "ITT1", "DTT0", "DTT1", "BUSC",
- "USP ", "VBR ", "CAAR", "MSP ", "ISP ", "MMUS", "URP ", "SRP ", "PCR ", 0 };
-
-static uae_u32 val_move2c (int regno)
+struct cpum2c m2cregs[] = {
+ 0, "SFC",
+ 1, "DFC",
+ 2, "CACR",
+ 3, "TC",
+ 4, "ITT0",
+ 5, "ITT1",
+ 6, "DTT0",
+ 7, "DTT1",
+ 8, "BUSC",
+ 0x800, "USP",
+ 0x801, "VBR",
+ 0x802, "CAAR",
+ 0x803, "MSP",
+ 0x804, "ISP",
+ 0x805, "MMUS",
+ 0x806, "URP",
+ 0x807, "SRP",
+ 0x808, "PCR",
+ -1, NULL
+};
+
+uae_u32 val_move2c (int regno)
{
switch (regno) {
case 0: return regs.sfc;
if (regs.s && regs.m) regs.msp = m68k_areg(®s, 7);
if (regs.s && regs.m == 0) regs.isp = m68k_areg(®s, 7);
j = 2;
- f_out(f, " USP %08.8X ISP %08.8X", regs.usp, regs.isp);
- for (i = 0; m2cregn[i] >= 0; i++) {
- if (!movec_illg(m2cregn[i])) {
+ f_out(f, " USP %08.8X ISP %08.8X ", regs.usp, regs.isp);
+ for (i = 0; m2cregs[i].regno>= 0; i++) {
+ if (!movec_illg(m2cregs[i].regno)) {
if (j > 0 && (j % 4) == 0)
f_out(f, "\n");
- f_out (f, "%s %08.8X ", m2cregs[i], val_move2c(m2cregn[i]));
+ f_out (f, "%s %08.8X ", m2cregs[i].regname, val_move2c(m2cregs[i].regno));
j++;
}
}
struct device_functions devicefunc_win32_aspi = {
open_scsi_bus, close_scsi_bus, open_scsi_device, close_scsi_device, info_device,
execscsicmd_out, execscsicmd_in, execscsicmd_direct,
- 0, 0, 0, 0, 0, 0, 0, check_isatapi, scsi_info, 0
+ 0, 0, 0, 0, 0, 0, 0, 0, check_isatapi, scsi_info, 0
};
}
}
-static int ioctl_command_readwrite (int unitnum, int sector, int write)
+int track_mode = -1;
+static int tm[] = { YellowMode2, XAForm2, RawWithC2AndSubCode, RawWithC2, RawWithSubCode };
+static uae_u8 *ioctl_command_rawread_2 (int unitnum, int sector, int size)
+{
+ int cnt = 3;
+ RAW_READ_INFO rri;
+ DWORD len;
+ uae_u8 *p = ciw32[unitnum].tempbuffer;
+
+ if (log_scsi)
+ write_log("rawread unit=%d sector=%d blocksize=%d tm=%d\n", unitnum, sector, size, tm[track_mode]);
+ if (!open_createfile(unitnum))
+ return 0;
+ if (size != 2336 && size != 2352 && size != 2048)
+ return 0;
+ while (cnt-- > 0) {
+ gui_cd_led (1);
+ seterrormode (unitnum);
+ rri.DiskOffset.QuadPart = sector * 2048;
+ rri.SectorCount = 1;
+ rri.TrackMode = tm[track_mode];
+ len = size;
+ if (!DeviceIoControl(ciw32[unitnum].h, IOCTL_CDROM_RAW_READ, &rri, sizeof rri,
+ p, IOCTL_DATA_BUFFER, &len, NULL)) {
+ reseterrormode (unitnum);
+ if (win32_error (unitnum, "IOCTL_CDROM_RAW_READ") < 0)
+ continue;
+ return 0;
+ }
+ reseterrormode (unitnum);
+ break;
+ }
+ if (size == 2352)
+ return p;
+ return p + 16;
+}
+
+static int ioctl_command_readwrite (int unitnum, int sector, int write, int blocksize)
{
DWORD dtotal;
int cnt = 3;
gui_cd_led (1);
seterrormode (unitnum);
if (write) {
- if (!WriteFile (ciw32[unitnum].h, ciw32[unitnum].tempbuffer, ciw32[unitnum].blocksize, &dtotal, 0)) {
+ if (!WriteFile (ciw32[unitnum].h, ciw32[unitnum].tempbuffer, blocksize, &dtotal, 0)) {
int err;
reseterrormode (unitnum);
err = win32_error (unitnum, "WriteFile");
return 0;
}
} else {
- if (!ReadFile (ciw32[unitnum].h, ciw32[unitnum].tempbuffer, ciw32[unitnum].blocksize, &dtotal, 0)) {
+ if (!ReadFile (ciw32[unitnum].h, ciw32[unitnum].tempbuffer, blocksize, &dtotal, 0)) {
reseterrormode (unitnum);
if (win32_error (unitnum, "ReadFile") < 0)
continue;
static int ioctl_command_write (int unitnum, int sector)
{
- return ioctl_command_readwrite (unitnum, sector, 1);
+ return ioctl_command_readwrite (unitnum, sector, 1, ciw32[unitnum].blocksize);
}
+
static uae_u8 *ioctl_command_read (int unitnum, int sector)
{
- if (ioctl_command_readwrite (unitnum, sector, 0) > 0)
+ if (ioctl_command_readwrite (unitnum, sector, 0, ciw32[unitnum].blocksize) > 0)
return ciw32[unitnum].tempbuffer;
return NULL;
}
+static uae_u8 *ioctl_command_rawread (int unitnum, int sector, int size)
+{
+ if (track_mode < 0) {
+ if (ioctl_command_readwrite (unitnum, sector, 0, size) > 0)
+ return ciw32[unitnum].tempbuffer;
+ return NULL;
+ }
+ return ioctl_command_rawread_2 (unitnum, sector, size);
+}
static int fetch_geometry (int unitnum, struct device_info *di)
{
open_bus, close_bus, open_device, close_device, info_device,
0, 0, 0,
ioctl_command_pause, ioctl_command_stop, ioctl_command_play, ioctl_command_qcode,
- ioctl_command_toc, ioctl_command_read, ioctl_command_write, 0, ioctl_scsi_info, ioctl_ismedia
+ ioctl_command_toc, ioctl_command_read, ioctl_command_rawread, ioctl_command_write,
+ 0, ioctl_scsi_info, ioctl_ismedia
};
#endif
struct device_functions devicefunc_win32_spti = {
open_scsi_bus, close_scsi_bus, open_scsi_device, close_scsi_device, info_device,
execscsicmd_out, execscsicmd_in, execscsicmd_direct,
- 0, 0, 0, 0, 0, 0, 0, check_isatapi, scsi_info, 0
+ 0, 0, 0, 0, 0, 0, 0, 0, check_isatapi, scsi_info, 0
};
static int getCDROMProperty(int idx, HDEVINFO DevInfo, const GUID *guid)
#include <string.h>
#include <windows.h>
+#include <commctrl.h>
#include "resource.h"
#include "options.h"
#include "memory.h"
#include "custom.h"
#include "newcpu.h"
+#include "cia.h"
+#include "disk.h"
#include "debug.h"
+#include "identify.h"
+#include "savestate.h"
#include "debug_win32.h"
#include "win32.h"
#include "win32gui.h"
#define MAXINPUTHIST 50
#define MAXPAGECONTROLS 5
#define MAXPAGES 10
+#define CLASSNAMELENGTH 50
static int inputfinished = 0;
-static FARPROC OldInputProc, OldMemInputProc;
static WORD* dlgtmpl;
static int reopen;
static int currpage, pages;
static int pagetype;
+char *pname[] = { "OUT1", "OUT2", "MEM1", "MEM2", "DASM1", "DASM2", "BRKPTS", "MISC", "CUSTOM" };
+static int pstatuscolor[MAXPAGES];
+
static void OutputCurrHistNode(HWND hWnd)
{
int txtlen;
}
}
+static HWND ulbs_hwnd;
+static int ulbs_pos;
static void UpdateListboxString(HWND hWnd, int pos, char *out, int mark)
{
int count;
- char text[MAX_LINEWIDTH + 1];
+ char text[MAX_LINEWIDTH + 1], *p;
COLORREF cr;
- if (!IsWindowEnabled(hWnd))
- return;
+ if (!IsWindowEnabled(hWnd)) {
+ p = strchr(out, ':');
+ if (p)
+ *(p + 1) = '\0';
+ }
if (strlen(out) > MAX_LINEWIDTH)
out[MAX_LINEWIDTH] = '\0';
+ p = strchr(out, '\n');
+ if (p)
+ *p = '\0';
cr = GetSysColor(COLOR_WINDOWTEXT);
count = SendMessage(hWnd, (UINT) LB_GETCOUNT, 0, 0);
if (pos < count) {
SendMessage(hWnd, LB_INSERTSTRING, pos, (LPARAM)out);
SendMessage(hWnd, LB_SETITEMDATA, pos, cr);
}
+static void ULBSINIT(HWND hwnd)
+{
+ ulbs_hwnd = hwnd;
+ ulbs_pos = 0;
+}
+static void ULBS(const char *format, ...)
+{
+ char buffer[MAX_LINEWIDTH + 1];
+ va_list parms;
+ va_start(parms, format);
+ _vsnprintf(buffer, MAX_LINEWIDTH, format, parms);
+ UpdateListboxString(ulbs_hwnd, ulbs_pos++, buffer, FALSE);
+}
+static void ULBST(const char *format, ...)
+{
+ char buffer[MAX_LINEWIDTH + 1];
+ va_list parms;
+ va_start(parms, format);
+ _vsnprintf(buffer, MAX_LINEWIDTH, format, parms);
+ UpdateListboxString(ulbs_hwnd, ulbs_pos++, buffer, TRUE);
+}
static int GetLBOutputLines(HWND hWnd)
{
return lines;
}
+static void ShowMiscCPU(HWND hwnd)
+{
+ int line = 0;
+ char out[MAX_LINEWIDTH + 1];
+ int i;
+
+ for (i = 0; m2cregs[i].regno>= 0; i++) {
+ if (!movec_illg(m2cregs[i].regno)) {
+ sprintf(out, "%-4s %08.8X", m2cregs[i].regname, val_move2c(m2cregs[i].regno));
+ UpdateListboxString(hwnd, line++, out, TRUE);
+ }
+ }
+}
+
+static int dcustom[] = {
+ 0x02, 0x9a, 0x9c, 0x8080, 0x8084, 0x8e, 0x90, 0x92, 0x94,
+ 0x100, 0x102, 0x104, 0x106, 0x10c, 0
+};
+static uae_u32 gw(uae_u8 *p, int off)
+{
+ return (p[off] << 8) | p[off + 1];
+}
+static void ShowCustomSmall(HWND hwnd)
+{
+ int len, i, j, cnt;
+ uae_u8 *p1, *p2, *p3, *p4;
+ char out[MAX_LINEWIDTH + 1];
+
+ p1 = p2 = save_custom (&len, 0, 1);
+ p1 += 4; // skip chipset type
+ for (i = 0; i < 4; i++) {
+ p4 = p1 + 0xa0 + i * 16;
+ p3 = save_audio (i, &len, 0);
+ p4[0] = p3[12];
+ p4[1] = p3[13];
+ p4[2] = p3[14];
+ p4[3] = p3[15];
+ p4[4] = p3[4];
+ p4[5] = p3[5];
+ p4[6] = p3[8];
+ p4[7] = p3[9];
+ p4[8] = 0;
+ p4[9] = p3[1];
+ p4[10] = p3[10];
+ p4[11] = p3[11];
+ free (p3);
+ }
+ ULBSINIT(hwnd);
+ cnt = 0;
+ sprintf(out, "CPU %d", currprefs.cpu_model);
+ if (currprefs.fpu_model)
+ sprintf (out + strlen(out), "/%d", currprefs.fpu_model);
+ sprintf(out + strlen(out), " %s", (currprefs.chipset_mask & CSMASK_AGA) ? "AGA" : ((currprefs.chipset_mask & CSMASK_ECS_AGNUS) ? "ECS" : "OCS"));
+ ULBST(out);
+ ULBST("VPOS %04.4X (%d)", vpos, vpos);
+ ULBST("HPOS %04.4X (%d)", current_hpos(), current_hpos());
+ for (i = 0; dcustom[i]; i++) {
+ for (j = 0; custd[j].name; j++) {
+ if (custd[j].adr == (dcustom[i] & 0x1fe) + 0xdff000) {
+ if (dcustom[i] & 0x8000)
+ ULBST("%-8s %08.8X", custd[j].name, (gw(p1, dcustom[i] & 0x1fe) << 16) | gw(p1, (dcustom[i] & 0x1fe) + 2));
+ else
+ ULBST("%-8s %04.4X", custd[j].name, gw(p1, dcustom[i] & 0x1fe));
+ break;
+ }
+ }
+ }
+ free (p2);
+}
+
+static void ShowMisc(void)
+{
+ int line = 0;
+ HWND hMisc;
+ int len, i;
+ uae_u8 *p, *p2;
+
+ hMisc = GetDlgItem(hDbgWnd, IDC_DBG_MISC);
+ ULBSINIT(hMisc);
+ for (i = 0; i < 2; i++) {
+ p = p2 = save_cia (i, &len, NULL);
+ ULBS("");
+ ULBS("CIA %c:", i == 1 ? 'B' : 'A');
+ ULBS("");
+ ULBS("PRA %02X PRB %02X", p[0], p[1]);
+ ULBS("DRA %02X DRB %02X", p[2], p[3]);
+ ULBS("CRA %02X CRB %02X ICR %02X IM %02X",
+ p[14], p[15], p[13], p[16]);
+ ULBS("TA %04X (%04X) TB %04X (%04X)",
+ (p[5] << 8) | p[4], (p[18] << 8) | p[17],
+ (p[7] << 8) | p[6], (p[20] << 8) | p[19]);
+ ULBS("TOD %06X (%06X) ALARM %06X %c%c",
+ (p[10] << 16) | (p[ 9] << 8) | p[ 8],
+ (p[23] << 16) | (p[22] << 8) | p[21],
+ (p[26] << 16) | (p[25] << 8) | p[24],
+ (p[27] & 1) ? 'L' : ' ', (p[27] & 2) ? ' ' : 'S');
+ free(p2);
+ }
+ for (i = 0; i < 4; i++) {
+ p = p2 = save_disk (i, &len, NULL);
+ ULBS("");
+ ULBS("Drive DF%d: (%s)", i, (p[4] & 2) ? "disabled" : "enabled");
+ ULBS("ID %08.8X Motor %s Cylinder %2d MFMPOS %d",
+ (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3],
+ (p[4] & 1) ? "On" : "Off",
+ p[5], (p[8] << 24) | (p[9] << 16) | (p[10] << 8) | p[11]);
+ if (p[16])
+ ULBS("'%s'", p + 16);
+ else
+ ULBS("Drive is empty");
+ free(p2);
+ }
+ p = p2 = save_floppy (&len, NULL);
+ ULBS("");
+ ULBS("Disk controller:");
+ ULBS("");
+ ULBS("Shift register: Data=%04.4X Shift=%d. DMA=%d,%d", (p[0] << 8) | p[1], p[2], p[3], p[5]);
+ free (p2);
+}
+
+static void ShowCustom(void)
+{
+ int len, i, j, end;
+ uae_u8 *p1, *p2, *p3, *p4;
+
+ ULBSINIT(GetDlgItem(hDbgWnd, IDC_DBG_CUSTOM));
+ p1 = p2 = save_custom (&len, 0, 1);
+ p1 += 4; // skip chipset type
+ for (i = 0; i < 4; i++) {
+ p4 = p1 + 0xa0 + i * 16;
+ p3 = save_audio (i, &len, 0);
+ p4[0] = p3[12];
+ p4[1] = p3[13];
+ p4[2] = p3[14];
+ p4[3] = p3[15];
+ p4[4] = p3[4];
+ p4[5] = p3[5];
+ p4[6] = p3[8];
+ p4[7] = p3[9];
+ p4[8] = 0;
+ p4[9] = p3[1];
+ p4[10] = p3[10];
+ p4[11] = p3[11];
+ free (p3);
+ }
+ end = 0;
+ while (custd[end].name)
+ end++;
+ end++;
+ end /= 2;
+ for (i = 0; i < end; i++) {
+ uae_u16 v1, v2;
+ int addr1, addr2;
+ j = end + i;
+ addr1 = custd[i].adr & 0x1ff;
+ addr2 = custd[j].adr & 0x1ff;
+ v1 = (p1[addr1 + 0] << 8) | p1[addr1 + 1];
+ v2 = (p1[addr2 + 0] << 8) | p1[addr2 + 1];
+ ULBS("%03.3X %-15s %04.4X %03.3X %-15s %04.4X",
+ addr1, custd[i].name, v1,
+ addr2, custd[j].name, v2);
+ }
+ free (p2);
+}
+
+static void ShowBreakpoints(void)
+{
+ HWND hBrkpts;
+ int i, line = 0, lines_old, got;
+ char outbp[MAX_LINEWIDTH + 1], outw[50];
+
+ hBrkpts = GetDlgItem(hDbgWnd, IDC_DBG_BRKPTS);
+ ULBSINIT(hBrkpts);
+ lines_old = SendMessage(hBrkpts, LB_GETCOUNT, 0, 0);
+ ULBS("");
+ ULBS("Breakpoints:");
+ ULBS("");
+ got = 0;
+ for (i = 0; i < BREAKPOINT_TOTAL; i++) {
+ if (!bpnodes[i].enabled)
+ continue;
+ m68k_disasm_2(outbp, sizeof(outbp), bpnodes[i].addr, NULL, 1, NULL, NULL, 0);
+ ULBS(outbp);
+ got = 1;
+ }
+ if (!got)
+ ULBS("none");
+ ULBS("");
+ ULBS("Memwatch breakpoints:");
+ ULBS("");
+ got = 0;
+ for (i = 0; i < MEMWATCH_TOTAL; i++) {
+ if (mwnodes[i].size == 0)
+ continue;
+ memwatch_dump2(outw, sizeof(outw), i);
+ ULBS(outw);
+ got = 1;
+ }
+ if (!got)
+ ULBS("none");
+ for (i = ulbs_pos; i < lines_old; i++)
+ SendMessage(hBrkpts, LB_DELETESTRING, line, 0);
+}
+
static void ShowMem(int offset)
{
uae_u32 addr;
- int i;
+ int i, lines_old, lines_new;
char out[MAX_LINEWIDTH + 1];
HWND hMemory;
dbgpage[currpage].addr += offset;
addr = dbgpage[currpage].addr;
hMemory = GetDlgItem(hDbgWnd, IDC_DBG_MEM);
- for (i = 0; i < GetLBOutputLines(hMemory); i++) {
+ lines_old = SendMessage(hMemory, LB_GETCOUNT, 0, 0);
+ lines_new = GetLBOutputLines(hMemory);
+ for (i = 0; i < lines_new; i++) {
addr = dumpmem2(addr, out, sizeof(out));
UpdateListboxString(hMemory, i, out, FALSE);
}
+ for (i = lines_new; i < lines_old; i++) {
+ SendMessage(hMemory, LB_DELETESTRING, lines_new, 0);
+ }
+ SendMessage(hMemory, LB_SETTOPINDEX, 0, 0);
}
static int GetPrevAddr(uae_u32 addr, uae_u32 *prevaddr)
static void ShowDasm(int direction)
{
uae_u32 addr = 0, prev;
- int i;
- char out[MAX_LINEWIDTH + 1], *p;
+ int i, lines_old, lines_new;
+ char out[MAX_LINEWIDTH + 1];
HWND hDasm;
hDasm = GetDlgItem(hDbgWnd, IDC_DBG_DASM);
if (addr % 2)
return;
dbgpage[currpage].addr = addr;
- for (i = 0; i < GetLBOutputLines(hDasm); i++) {
+ lines_old = SendMessage(hDasm, LB_GETCOUNT, 0, 0);
+ lines_new = GetLBOutputLines(hDasm);
+ for (i = 0; i < lines_new; i++) {
m68k_disasm_2(out, sizeof(out), addr, &addr, 1, NULL, NULL, 0);
- p = strchr(out, '\n');
- if (p)
- *p = '\0';
if (addr > dbgpage[currpage].addr)
UpdateListboxString(hDasm, i, out, FALSE);
else
UpdateListboxString(hDasm, i, "", FALSE);
}
+ for (i = lines_new; i < lines_old; i++) {
+ SendMessage(hDasm, LB_DELETESTRING, lines_new, 0);
+ }
+ SendMessage(hDasm, LB_SETTOPINDEX, 0, 0);
}
static void SetMemToPC(void)
static void ShowPage(int index, int force)
{
int i, id;
+ HWND hwnd;
if (index >= pages || ((index == currpage) && !force))
return;
if (currpage >= 0) {
+ pstatuscolor[currpage] = (currpage < 2 && index > 1) ? COLOR_WINDOWTEXT : COLOR_GRAYTEXT;
+ if (index < 2)
+ pstatuscolor[index == 0 ? 1 : 0] = COLOR_GRAYTEXT;
for (i = 0; i < MAXPAGECONTROLS; i++) {
if (dbgpage[currpage].ctrl[i]) {
id = GetDlgCtrlID(dbgpage[currpage].ctrl[i]);
}
}
pagetype = 0;
- currpage = index;
for (i = 0; i < MAXPAGECONTROLS; i++) {
if (dbgpage[index].ctrl[i]) {
id = GetDlgCtrlID(dbgpage[index].ctrl[i]);
if (id == IDC_DBG_OUTPUT1 || id == IDC_DBG_OUTPUT2) {
hOutput = dbgpage[index].ctrl[i];
- } else if (id == IDC_DBG_MEM) {
+ } else if (id == IDC_DBG_MEM) {
ShowMem(0);
pagetype = id;
} else if (id == IDC_DBG_DASM) {
pagetype = id;
} else if (id == IDC_DBG_MEMINPUT) {
SetWindowText(dbgpage[index].ctrl[i], dbgpage[index].addrinput);
- }
+ } else if (id == IDC_DBG_BRKPTS) {
+ ShowBreakpoints();
+ } else if (id == IDC_DBG_MISC) {
+ ShowMisc();
+ } else if (id == IDC_DBG_CUSTOM) {
+ ShowCustom();
+ }
ShowWindow(dbgpage[index].ctrl[i], SW_SHOW);
}
}
+ currpage = index;
+ pstatuscolor[currpage] = COLOR_HIGHLIGHT;
+ hwnd = GetDlgItem(hDbgWnd, IDC_DBG_STATUS);
+ RedrawWindow(hwnd, 0, 0, RDW_INVALIDATE);
}
-static void AddPage(int *iddata) // iddata[0] = idcount!
+static void AddPage(int *iddata)
{
int i;
if (pages >= MAXPAGES)
return;
memset(&dbgpage[pages], 0, sizeof(struct debuggerpage));
- for (i = 0; i < iddata[0]; i++) {
- dbgpage[pages].ctrl[i] = GetDlgItem(hDbgWnd, iddata[i + 1]);
+ for (i = 0; iddata[i] > 0; i++) {
+ dbgpage[pages].ctrl[i] = GetDlgItem(hDbgWnd, iddata[i]);
ShowWindow(dbgpage[pages].ctrl[i], SW_HIDE);
}
pages++;
}
+static int GetTextSize(HWND hWnd, char *text, int width)
+{
+ HDC hdc;
+ TEXTMETRIC tm;
+ HFONT hfont, hfontold;
+ hdc = GetDC(hWnd);
+ hfont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
+ hfontold = (HFONT)SelectObject(hdc, hfont);
+ GetTextMetrics(hdc, &tm);
+ SelectObject(hdc, hfontold);
+ ReleaseDC(hWnd, hdc);
+ if (!width)
+ return tm.tmHeight + tm.tmExternalLeading;
+ else if (text)
+ return tm.tmMaxCharWidth * strlen(text);
+ return 0;
+}
+
static void InitPages(void)
{
- int i;
+ int i, parts[MAXPAGES], width, pwidth = 0;
+ HWND hwnd;
int dpage[][MAXPAGECONTROLS + 1] = {
- { 1, IDC_DBG_OUTPUT1 },
- { 1, IDC_DBG_OUTPUT2 },
- { 4, IDC_DBG_MEM, IDC_DBG_MEMINPUT, IDC_DBG_MEMUP, IDC_DBG_MEMDOWN },
- { 4, IDC_DBG_MEM, IDC_DBG_MEMINPUT, IDC_DBG_MEMUP, IDC_DBG_MEMDOWN },
- { 5, IDC_DBG_DASM, IDC_DBG_MEMINPUT, IDC_DBG_MEMTOPC },
- { 5, IDC_DBG_DASM, IDC_DBG_MEMINPUT, IDC_DBG_MEMTOPC }
+ { IDC_DBG_OUTPUT1, -1 },
+ { IDC_DBG_OUTPUT2, -1 },
+ { IDC_DBG_MEM, IDC_DBG_MEMINPUT, -1 },
+ { IDC_DBG_MEM, IDC_DBG_MEMINPUT, -1 },
+ { IDC_DBG_DASM, IDC_DBG_MEMINPUT, IDC_DBG_MEMTOPC, -1 },
+ { IDC_DBG_DASM, IDC_DBG_MEMINPUT, IDC_DBG_MEMTOPC, -1 },
+ { IDC_DBG_BRKPTS, -1 },
+ { IDC_DBG_MISC, -1 },
+ { IDC_DBG_CUSTOM, -1 }
};
pages = 0;
for (i = 0; i < (sizeof(dpage) / sizeof(dpage[0])); i++)
AddPage(dpage[i]);
+ memset(parts, 0, MAXPAGES * sizeof(int));
+ width = GetTextSize(hDbgWnd, "12345678", TRUE); // longest pagename + 2
+ for (i = 0; i < pages; i++) {
+ pwidth += width;
+ parts[i] = pwidth;
+ }
+ hwnd = GetDlgItem(hDbgWnd, IDC_DBG_STATUS);
+ SendMessage(hwnd, SB_SETPARTS, (WPARAM)pages, (LPARAM)parts);
+ for (i = 0; i < pages; i++) {
+ SendMessage(hwnd, SB_SETTEXT, i | SBT_OWNERDRAW, 0);
+ pstatuscolor[i] = COLOR_GRAYTEXT;
+ }
}
static LRESULT CALLBACK InputProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
- switch (message) {
+ WNDPROC oldproc;
+
+ switch (message) {
case WM_KEYUP:
switch (wParam) {
case VK_RETURN:
}
break;
}
- return CallWindowProc((WNDPROC)OldInputProc, hWnd, message, wParam, lParam);
+ oldproc = (WNDPROC)GetWindowLongPtr(hWnd, GWL_USERDATA);
+ return CallWindowProc(oldproc, hWnd, message, wParam, lParam);
}
static LRESULT CALLBACK MemInputProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
int ok = 1;
char addrstr[11];
uae_u32 addr;
+ WNDPROC oldproc;
switch (message) {
case WM_CHAR:
}
break;
}
- return CallWindowProc((WNDPROC)OldMemInputProc, hWnd, message, wParam, lParam);
+ oldproc = (WNDPROC)GetWindowLongPtr(hWnd, GWL_USERDATA);
+ return CallWindowProc(oldproc, hWnd, message, wParam, lParam);
+}
+
+static LRESULT CALLBACK ListboxProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ WNDPROC oldproc;
+ HWND hinput;
+
+ switch (message) {
+ case WM_CHAR:
+ hinput = GetDlgItem(hDbgWnd, IDC_DBG_INPUT);
+ SetFocus(hinput);
+ SendMessage(hinput, WM_CHAR, wParam, lParam);
+ return TRUE;
+ }
+ oldproc = (WNDPROC)GetWindowLongPtr(hWnd, GWL_USERDATA);
+ return CallWindowProc(oldproc, hWnd, message, wParam, lParam);
+}
+
+static LRESULT CALLBACK EditProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ WNDPROC oldproc;
+ HWND hinput;
+
+ switch (message) {
+ case WM_CHAR:
+ if (wParam != VK_CANCEL) { // not for Ctrl-C for copying
+ hinput = GetDlgItem(hDbgWnd, IDC_DBG_INPUT);
+ SetFocus(hinput);
+ SendMessage(hinput, WM_CHAR, wParam, lParam);
+ return TRUE;
+ }
+ break;
+ }
+ oldproc = (WNDPROC)GetWindowLongPtr(hWnd, GWL_USERDATA);
+ return CallWindowProc(oldproc, hWnd, message, wParam, lParam);
}
static void moveupdown(int dir)
static BOOL CALLBACK childenumproc (HWND hwnd, LPARAM lParam)
{
- int id1y[] = { IDC_DBG_OUTPUT1, IDC_DBG_OUTPUT2, IDC_DBG_MEM, IDC_DBG_DASM, -1 };
- int id2y[] = { IDC_DBG_INPUT, IDC_DBG_HELP, -1 };
+ int id1y[] = { IDC_DBG_OUTPUT1, IDC_DBG_OUTPUT2, IDC_DBG_MEM, IDC_DBG_DASM, IDC_DBG_BRKPTS, IDC_DBG_MISC, IDC_DBG_CUSTOM, -1 };
+ int id2y[] = { IDC_DBG_INPUT, IDC_DBG_HELP, IDC_DBG_STATUS, -1 };
int id1x[] = { IDC_DBG_OUTPUT1, IDC_DBG_OUTPUT2, IDC_DBG_MEM, IDC_DBG_DASM,
- IDC_DBG_AMEM, IDC_DBG_PREFETCH, IDC_DBG_INPUT, -1 };
- int id2x[] = { IDC_DBG_HELP, IDC_DBG_CCR, IDC_DBG_SP_VBR, IDC_DBG_MISC,
- IDC_DBG_FPREG, IDC_DBG_FPSR, -1 };
+ IDC_DBG_AMEM, IDC_DBG_PREFETCH, IDC_DBG_INPUT, IDC_DBG_STATUS, IDC_DBG_BRKPTS, IDC_DBG_MISC, IDC_DBG_CUSTOM, -1 };
+ int id2x[] = { IDC_DBG_HELP, IDC_DBG_CCR, IDC_DBG_SP_VBR, IDC_DBG_MMISC,
+ IDC_DBG_FPREG, IDC_DBG_FPSR, IDC_DBG_MCUSTOM, IDC_DBG_MISCCPU, -1 };
int dlgid, j;
AdjustWindowRect(&r2, WS_POPUP | WS_CAPTION | WS_THICKFRAME, FALSE);
dlgRect.left -= r2.left;
dlgRect.top -= r2.top;
- EnumChildWindows (hDlg, &childenumproc, 0);
+ EnumChildWindows (hDlg, childenumproc, 0);
dlgRect = r;
+ RedrawWindow(hDlg, 0, 0, RDW_INVALIDATE);
}
+static BOOL CALLBACK InitChildWindows(HWND hWnd, LPARAM lParam)
+{
+ int id, enable = TRUE;
+ WNDPROC newproc = NULL, oldproc;
+ char classname[CLASSNAMELENGTH];
+
+ id = GetDlgCtrlID(hWnd);
+ switch (id) {
+ case IDC_DBG_INPUT:
+ newproc = InputProc;
+ SendMessage(hWnd, EM_LIMITTEXT, MAX_LINEWIDTH, 0);
+ break;
+ case IDC_DBG_MEMINPUT:
+ newproc = MemInputProc;
+ SendMessage(hWnd, EM_LIMITTEXT, 8, 0);
+ break;
+ case IDC_DBG_PREFETCH:
+ newproc = ListboxProc;
+ enable = currprefs.cpu_compatible ? TRUE : FALSE;
+ break;
+ case IDC_DBG_FPREG:
+ case IDC_DBG_FPSR:
+ newproc = ListboxProc;
+ enable = currprefs.cpu_model < 68020 ? FALSE : TRUE;
+ break;
+ default:
+ if (GetClassName(hWnd, classname, CLASSNAMELENGTH)) {
+ if (!strcmp(classname, "ListBox"))
+ newproc = ListboxProc;
+ else if (!strcmp(classname, "Edit"))
+ newproc = EditProc;
+ }
+ break;
+ }
+ if (newproc) {
+ oldproc = (WNDPROC)SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG_PTR)newproc);
+ SetWindowLongPtr(hWnd, GWL_USERDATA, (LONG_PTR)oldproc);
+ }
+ EnableWindow(hWnd, enable);
+ return TRUE;
+}
static LRESULT CALLBACK DebuggerProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
- int len;
HWND hwnd;
DRAWITEMSTRUCT *pdis;
HDC hdc;
RECT rc;
char text[MAX_LINEWIDTH + 1];
- HFONT hfont, hfontold;
- TEXTMETRIC tm;
switch (message) {
case WM_INITDIALOG:
SetWindowPos(hDlg, 0, x, y, w, h, SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_DEFERERASE);
}
SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_APPICON)));
- hwnd = GetDlgItem(hDlg, IDC_DBG_INPUT);
- OldInputProc = (FARPROC)SetWindowLong(hwnd, GWL_WNDPROC, (DWORD)InputProc);
- SendMessage(hwnd, EM_LIMITTEXT, MAX_LINEWIDTH, 0);
- hwnd = GetDlgItem(hDlg, IDC_DBG_MEMINPUT);
- OldMemInputProc = (FARPROC)SetWindowLong(hwnd, GWL_WNDPROC, (DWORD)MemInputProc);
- SendMessage(hwnd, EM_LIMITTEXT, 8, 0);
- if (!currprefs.cpu_compatible) {
- hwnd = GetDlgItem(hDlg, IDC_DBG_PREFETCH);
- EnableWindow(hwnd, FALSE);
- }
- if (currprefs.cpu_model < 68020) {
- hwnd = GetDlgItem(hDlg, IDC_DBG_FPREG);
- EnableWindow(hwnd, FALSE);
- hwnd = GetDlgItem(hDlg, IDC_DBG_FPSR);
- EnableWindow(hwnd, FALSE);
- }
- currpage = -1;
- firsthist = lasthist = currhist = NULL;
- histcount = 0;
- inputfinished = 0;
+ EnumChildWindows(hDlg, InitChildWindows, 0);
+ currpage = -1;
+ firsthist = lasthist = currhist = NULL;
+ histcount = 0;
+ inputfinished = 0;
AdjustDialog(hDlg);
- return TRUE;
+ return TRUE;
}
case WM_CLOSE:
DestroyWindow(hDlg);
case WM_EXITSIZEMOVE:
{
AdjustDialog(hDlg);
+ ShowPage(currpage, TRUE);
return TRUE;
}
-
case WM_CTLCOLORSTATIC:
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
return (LRESULT)GetSysColorBrush(COLOR_WINDOW);
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_DBG_HELP:
+ {
+ HWND hinput;
WriteOutput(linebreak + 1, 2);
debug_help();
+ hinput = GetDlgItem(hDbgWnd, IDC_DBG_INPUT);
+ SetFocus(hinput);
return TRUE;
+ }
case ID_DBG_PAGE1:
case ID_DBG_PAGE2:
case ID_DBG_PAGE3:
case ID_DBG_PAGE4:
case ID_DBG_PAGE5:
case ID_DBG_PAGE6:
+ case ID_DBG_PAGE7:
+ case ID_DBG_PAGE8:
+ case ID_DBG_PAGE9:
// IDs have to be consecutive and in order of page order for this to work
ShowPage(LOWORD(wParam) - ID_DBG_PAGE1, FALSE);
return TRUE;
moveupdown(2);
return TRUE;
case IDC_DBG_MEMTOPC:
+ {
+ HWND hmeminput;
SetMemToPC();
+ hmeminput = GetDlgItem(hDbgWnd, IDC_DBG_MEMINPUT);
+ SetFocus(hmeminput);
return TRUE;
+ }
}
break;
case WM_MEASUREITEM:
- hdc = GetDC(hDlg);
- hfont = (HFONT)SendMessage(hDlg, WM_GETFONT, 0, 0);
- hfontold = (HFONT)SelectObject(hdc, hfont);
- GetTextMetrics(hdc, &tm);
- ((MEASUREITEMSTRUCT*)(lParam))->itemHeight = tm.tmHeight + tm.tmExternalLeading;
- SelectObject(hdc, hfontold);
- ReleaseDC(hDlg, hdc);
+ ((MEASUREITEMSTRUCT*)(lParam))->itemHeight = GetTextSize(hDlg, NULL, FALSE);
return TRUE;
case WM_DRAWITEM:
pdis = (DRAWITEMSTRUCT *)lParam;
hdc = pdis->hDC;
rc = pdis->rcItem;
SetBkMode(hdc, TRANSPARENT);
- if (pdis->itemID < 0) {
- if (pdis->itemAction & ODA_FOCUS)
- DrawFocusRect(hdc, &rc);
- return TRUE;
- }
- memset(text, MAX_LINEWIDTH + 1, 0);
- len = SendMessage(pdis->hwndItem, LB_GETTEXT, pdis->itemID, (LPARAM)(LPSTR)text);
- if (!IsWindowEnabled(pdis->hwndItem)) {
- FillRect(hdc, &rc, GetSysColorBrush(COLOR_3DFACE));
- SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
+ if (wParam == IDC_DBG_STATUS) {
+ SetTextColor(hdc, GetSysColor(pstatuscolor[pdis->itemID]));
+ DrawText(hdc, pname[pdis->itemID], lstrlen(pname[pdis->itemID]), &rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
}
else {
- FillRect(hdc, &rc, GetSysColorBrush(COLOR_WINDOW));
- SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
- }
- SetTextColor(hdc, pdis->itemData);
- if (len > 0)
+ if (pdis->itemID < 0) {
+ return TRUE;
+ }
+ memset(text, 0, MAX_LINEWIDTH + 1);
+ SendMessage(pdis->hwndItem, LB_GETTEXT, pdis->itemID, (LPARAM)(LPSTR)text);
+ if (!IsWindowEnabled(pdis->hwndItem)) {
+ FillRect(hdc, &rc, GetSysColorBrush(COLOR_3DFACE));
+ SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
+ }
+ else {
+ FillRect(hdc, &rc, GetSysColorBrush(COLOR_WINDOW));
+ SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
+ }
+ SetTextColor(hdc, pdis->itemData);
TextOut(hdc, rc.left, rc.top, text, strlen(text));
- if ((pdis->itemState) & (ODS_FOCUS))
- DrawFocusRect(hdc, &rc);
- return TRUE;
+ return TRUE;
+ }
+ break;
}
return FALSE;
}
struct instr *dp;
struct mnemolookup *lookup1, *lookup2;
uae_u32 fpsr;
+ char *fpsrflag[] = { "N: ", "Z: ", "I: ", "NAN: " };
if (!hDbgWnd)
return;
UpdateListboxString(hwnd, 0, out, TRUE);
sprintf(out, "ISP: %08lX", regs.isp);
UpdateListboxString(hwnd, 1, out, TRUE);
- sprintf(out, "MSP: %08lX", regs.msp);
- UpdateListboxString(hwnd, 2, out, TRUE);
- sprintf(out, "VBR: %08lX", regs.vbr);
- UpdateListboxString(hwnd, 3, out, TRUE);
- hwnd = GetDlgItem(hDbgWnd, IDC_DBG_MISC);
+ ShowMiscCPU(GetDlgItem(hDbgWnd, IDC_DBG_MISCCPU));
+
+ hwnd = GetDlgItem(hDbgWnd, IDC_DBG_MMISC);
sprintf(out, "T: %d%d", regs.t1, regs.t0);
UpdateListboxString(hwnd, 0, out, TRUE);
sprintf(out, "S: %d", regs.s);
sprintf(out, "Prefetch: %04X (%s) %04X (%s)", regs.irc, lookup1->name, regs.ir, lookup2->name);
UpdateListboxString(hwnd, 0, out, TRUE);
+ ShowCustomSmall(GetDlgItem(hDbgWnd, IDC_DBG_MCUSTOM));
+
hwnd = GetDlgItem(hDbgWnd, IDC_DBG_FPREG);
for (i = 0; i < 8; i++) {
sprintf(out, "FP%d: %g", i, regs.fp[i]);
hwnd = GetDlgItem(hDbgWnd, IDC_DBG_FPSR);
fpsr = get_fpsr();
- UpdateListboxString(hwnd, 0, ((fpsr & 0x8000000) != 0) ? "N: 1" : "N: 0", TRUE);
- UpdateListboxString(hwnd, 1, ((fpsr & 0x4000000) != 0) ? "Z: 1" : "Z: 0", TRUE);
- UpdateListboxString(hwnd, 2, ((fpsr & 0x2000000) != 0) ? "I: 1" : "I: 0", TRUE);
- UpdateListboxString(hwnd, 3, ((fpsr & 0x1000000) != 0) ? "NAN: 1" : "NAN: 0", TRUE);
-
+ for (i = 0; i < 4; i++) {
+ sprintf(out, "%s%d", fpsrflag[i], (fpsr & (0x8000000 >> i)) != 0 ? 1 : 0);
+ UpdateListboxString(hwnd, i, out, TRUE);
+ }
ShowPage(currpage, TRUE);
}
extern int GetInput (char *out, int maxlen);
extern int console_get_gui (char *out, int maxlen);
-#include <pshpack2.h>
-typedef struct {
- WORD dlgVer;
- WORD signature;
- DWORD helpID;
- DWORD exStyle;
- DWORD style;
- WORD cDlgItems;
- short x;
- short y;
- short cx;
- short cy;
-} DLGTEMPLATEEX;
-
-typedef struct {
- WORD pointsize;
- WORD weight;
- BYTE italic;
- BYTE charset;
- WCHAR typeface[0];
-} DLGTEMPLATEEX_END;
-
-typedef struct {
- DWORD helpID;
- DWORD exStyle;
- DWORD style;
- short x;
- short y;
- short cx;
- short cy;
- DWORD id;
-} DLGITEMTEMPLATEEX;
-#include <poppack.h>
-
#endif
#define IDC_DBG_CCR 1744
#define IDC_DBG_AMEM 1745
#define IDC_DBG_SP_VBR 1746
-#define IDC_DBG_MISC 1747
+#define IDC_DBG_MMISC 1747
#define IDC_DBG_PC 1748
#define IDC_DBG_PREFETCH 1749
#define IDC_DBG_FPREG 1750
#define IDC_DBG_MEMTOPC 1759
#define IDC_DBG_MEMUPFAST 1760
#define IDC_DA_RESET 1761
+#define IDC_DBG_STATUS 1762
+#define IDC_DBG_BRKPTS 1763
+#define IDC_DBG_MCUSTOM 1764
+#define IDC_DBG_MISC 1765
+#define IDC_DBG_CUSTOM 1766
+#define IDC_DBG_MISCCPU 1767
+
#define ID__FLOPPYDRIVES 40004
#define ID_FLOPPYDRIVES_DF0 40005
#define ID_ST_CONFIGURATION 40010
#define ID_DBG_PAGE4 40023
#define ID_DBG_PAGE5 40024
#define ID_DBG_PAGE6 40025
+#define ID_DBG_PAGE7 40026
+#define ID_DBG_PAGE8 40027
+#define ID_DBG_PAGE9 40028
// Next default values for new objects
//
#define _APS_NO_MFC 1
#define _APS_3D_CONTROLS 1
#define _APS_NEXT_RESOURCE_VALUE 253
-#define _APS_NEXT_COMMAND_VALUE 40026
-#define _APS_NEXT_CONTROL_VALUE 1761
+#define _APS_NEXT_COMMAND_VALUE 40029
+#define _APS_NEXT_CONTROL_VALUE 1768
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
VK_F4, ID_DBG_PAGE4, VIRTKEY, NOINVERT
VK_F5, ID_DBG_PAGE5, VIRTKEY, NOINVERT
VK_F6, ID_DBG_PAGE6, VIRTKEY, NOINVERT
+ VK_F7, ID_DBG_PAGE7, VIRTKEY, NOINVERT
+ VK_F8, ID_DBG_PAGE8, VIRTKEY, NOINVERT
+ VK_F9, ID_DBG_PAGE9, VIRTKEY, NOINVERT
VK_DOWN, IDC_DBG_MEMDOWN, VIRTKEY, ALT, NOINVERT
VK_RIGHT, IDC_DBG_MEMDOWNFAST, VIRTKEY, ALT, NOINVERT
VK_UP, IDC_DBG_MEMUP, VIRTKEY, ALT, NOINVERT
VK_LEFT, IDC_DBG_MEMUPFAST, VIRTKEY, ALT, NOINVERT
+ "h", IDC_DBG_HELP, VIRTKEY, ALT, NOINVERT
+ "p", IDC_DBG_MEMTOPC, VIRTKEY, ALT, NOINVERT
END
CTEXT "Custom input event",IDC_STRINGBOX_TEXT,23,5,187,10,SS_CENTERIMAGE | WS_TABSTOP
END
-IDD_DEBUGGER DIALOGEX 0, 0, 454, 298
+IDD_DEBUGGER DIALOGEX 0, 0, 454, 311
STYLE DS_LOCALEDIT | DS_SETFONT | DS_MODALFRAME | DS_3DLOOK | WS_POPUP | WS_CAPTION | WS_THICKFRAME
EXSTYLE WS_EX_CONTROLPARENT
CAPTION "WinUAE Debugger"
LISTBOX IDC_DBG_AMEM,106,1,231,66,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
LISTBOX IDC_DBG_CCR,338,1,57,42,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
LISTBOX IDC_DBG_SP_VBR,338,44,115,34,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
- LISTBOX IDC_DBG_MISC,396,1,57,42,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ LISTBOX IDC_DBG_MMISC,396,1,57,42,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
LISTBOX IDC_DBG_PC,1,68,52,10,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
LISTBOX IDC_DBG_PREFETCH,54,68,283,10,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
- LISTBOX IDC_DBG_FPREG,372,79,81,66,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
- LISTBOX IDC_DBG_FPSR,372,146,81,34,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ LISTBOX IDC_DBG_FPREG,372,218,81,66,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ LISTBOX IDC_DBG_FPSR,372,285,81,34,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ LISTBOX IDC_DBG_MISCCPU,372,319,81,34,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ CONTROL "",IDC_DBG_STATUS,"msctls_statusbar32",CCS_BOTTOM | SBARS_SIZEGRIP,0,298,453,12
+ LISTBOX IDC_DBG_BRKPTS,1,79,370,205,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL
+ LISTBOX IDC_DBG_MCUSTOM,372,79,81,138,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT
+ LISTBOX IDC_DBG_MISC,1,79,370,205,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL
+ LISTBOX IDC_DBG_CUSTOM,1,79,370,205,LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL
END
void toggle_mousegrab (void)
{
}
+#define LOG_BOOT "winuaebootlog.txt"
+#define LOG_NORMAL "winuaelog.txt"
void logging_open(int bootlog, int append)
{
debugfilename[0] = 0;
#ifndef SINGLEFILE
if (currprefs.win32_logfile)
- sprintf (debugfilename, "%swinuaelog.txt", start_path_data);
+ sprintf (debugfilename, "%s%s", start_path_data, LOG_NORMAL);
if (bootlog)
- sprintf (debugfilename, "%swinuaebootlog.txt", start_path_data);
+ sprintf (debugfilename, "%s%s", start_path_data, LOG_BOOT);
if (debugfilename[0]) {
if (!debugfile)
debugfile = log_open (debugfilename, append, bootlog);
return;
}
if (first == 1) {
+ write_log("Log (%s): '%s%s'\n", currprefs.win32_logfile ? "enabled" : "disabled",
+ start_path_data, LOG_NORMAL);
if (debugfile)
log_close (debugfile);
debugfile = 0;
}
if (i + 1 < argc) {
char *np = argv[i + 1];
+
+ if (!strcmp (arg, "-trackmode")) {
+ extern int track_mode;
+ track_mode = getval (np);
+ i++;
+ continue;
+ }
if (!strcmp (arg, "-affinity")) {
cpu_affinity = getval (np);
i++;
#define GETBDM(x) (((x) - ((x / 10000) * 10000)) / 100)
#define GETBDD(x) ((x) % 100)
-#define WINUAEBETA 9
+#define WINUAEBETA 10
#define WINUAEPUBLICBETA 1
-#define WINUAEDATE MAKEBD(2007, 4, 25)
+#define WINUAEDATE MAKEBD(2007, 5, 1)
//#define WINUAEEXTRA ""
#define IHF_WINDOWHIDDEN 6
static int max_w, max_h, mult, pointsize;
+#include <pshpack2.h>
typedef struct {
WORD dlgVer;
WORD signature;
/*
sz_Or_Ord menu;
sz_Or_Ord windowClass;
+ WCHAR title[titleLen];
*/
} DLGTEMPLATEEX;
short cx;
short cy;
WORD id;
+ WORD reserved;
WCHAR windowClass[0];
/* variable data after this */
/* sz_Or_Ord title; */
/* WORD extraCount; */
} DLGITEMTEMPLATEEX;
+#include <poppack.h>
static int fontsdetected, font_vista_ok, font_xp_ok;
static wchar_t wfont_vista[] = L"Segoe UI";
p = (BYTE*)d + sizeof (DLGTEMPLATEEX);
p = skiptext(p);
p = skiptext(p);
+ p = skiptext(p);
d2 = (DLGTEMPLATEEX_END*)p;
p2 = p;
p2 += sizeof (DLGTEMPLATEEX_END);
+Beta 10:
+
+- CDTV CDROM command 0x09 (play audio cd in lsn mode) fixed, parameters
+ are start sector and number of sectors, not start and end sector..
+- state file load: keep current disk in drive if image's path in state
+ file does not exist. (keeps some programs happy that don't access the
+ disk but start complaining if disk is suddenly ejected)
+- fixed stupid typo in fpu clamping fix (327676 instead of 32767..)
+- CDTV audio cd end position detection didn't always work
+- GUI debugger improvements (Karsten Bock & TW)
+
Beta 9:
- new PAL filter configuration file support (forgot it in b8)
enabled (uaescsi, uaeserial, bsdsocket etc..) Previously it was
only mapped if filesystem (directory or hdf) was configured.
- IDE non-RDB HDF statefile support added
-- filter default centering fixed (I think..)
+- filter default centering fixed (I think..) and other related tweaks
- minor FPU updates to very rarely used instructions (from aranym)
- "cpu060_revision" config entry added ("read-only", not created when
saving config), sets 68060 revision field in PCR register (current
default is 1)
-
Beta 8:
- very long CDTV CD reads don't freeze anymore (overflow in CD
projects / francis / winuae.git / commitdiff