static int simon_dump(void)
{
mon_out("$8000-$9FFF ROM: enabled\n");
mon_out("$A000-$BFFF ROM: %s\n", (simon_a000) ? "enabled" : "disabled");
return 0;
}
void mon_memory_compare(MON_ADDR start_addr, MON_ADDR end_addr, MON_ADDR dest)
{
WORD start;
MEMSPACE src_mem, dest_mem;
BYTE byte1, byte2;
unsigned int i, dst;
int len;
len = mon_evaluate_address_range(&start_addr, &end_addr, TRUE, -1);
if (len < 0) {
mon_out("Invalid range.\n");
return;
}
src_mem = addr_memspace(start_addr);
start = addr_location(start_addr);
mon_evaluate_default_addr(&dest);
dst = addr_location(dest);
dest_mem = addr_memspace(dest);
for (i = 0; (int)i < len; i++) {
byte1 = mon_get_mem_val(src_mem, (WORD)ADDR_LIMIT(start + i));
byte2 = mon_get_mem_val(dest_mem, (WORD)ADDR_LIMIT(dst + i));
if (byte1 != byte2) {
mon_out("$%04x $%04x: %02x %02x\n",
ADDR_LIMIT(start + i), ADDR_LIMIT(dst + i), byte1, byte2);
}
}
}
/* TODO: should use mon_register_list_get */
static void mon_register_print(int mem)
{
h6809_regs_t *regs;
if (monitor_diskspace_dnr(mem) >= 0) {
if (!check_drive_emu_level_ok(monitor_diskspace_dnr(mem) + 8)) {
return;
}
} else if (mem != e_comp_space) {
log_error(LOG_ERR, "Unknown memory space!");
return;
}
regs = mon_interfaces[mem]->h6809_cpu_regs;
mon_out(" ADDR A B X Y SP U DP EFHINZVC\n");
mon_out(".;%04x %02x %02x %04x %04x %04x %04x %02x %c%c%c%c%c%c%c%c\n",
addr_location(mon_register_get_val(mem, e_PC)),
mon_register_get_val(mem, e_A),
mon_register_get_val(mem, e_B),
mon_register_get_val(mem, e_X),
mon_register_get_val(mem, e_Y),
mon_register_get_val(mem, e_SP),
mon_register_get_val(mem, e_U),
mon_register_get_val(mem, e_DP),
(H6809_REGS_TEST_E(regs) ? '1' : '.'),
(H6809_REGS_TEST_F(regs) ? '1' : '.'),
(H6809_REGS_TEST_H(regs) ? '1' : '.'),
(H6809_REGS_TEST_I(regs) ? '1' : '.'),
(H6809_REGS_TEST_N(regs) ? '1' : '.'),
(H6809_REGS_TEST_Z(regs) ? '1' : '.'),
(H6809_REGS_TEST_V(regs) ? '1' : '.'),
(H6809_REGS_TEST_C(regs) ? '1' : '.')
);
}
static void mon_register_print(int mem)
{
z80_regs_t *regs;
if (monitor_diskspace_dnr(mem) >= 0) {
if (!check_drive_emu_level_ok(monitor_diskspace_dnr(mem) + 8))
return;
} else if (mem != e_comp_space) {
log_error(LOG_ERR, "Unknown memory space!");
return;
}
regs = mon_interfaces[mem]->z80_cpu_regs;
mon_out(" ADDR AF BC DE HL IX IY SP I R AF' BC' DE' HL'\n");
mon_out(".;%04x %04x %04x %04x %04x %04x %04x %04x %02x %02x %04x %04x %04x %04x\n",
addr_location(mon_register_get_val(mem, e_PC)),
mon_register_get_val(mem, e_AF),
mon_register_get_val(mem, e_BC),
mon_register_get_val(mem, e_DE),
mon_register_get_val(mem, e_HL),
mon_register_get_val(mem, e_IX),
mon_register_get_val(mem, e_IY),
mon_register_get_val(mem, e_SP),
mon_register_get_val(mem, e_I),
mon_register_get_val(mem, e_R),
mon_register_get_val(mem, e_AF2),
mon_register_get_val(mem, e_BC2),
mon_register_get_val(mem, e_DE2),
mon_register_get_val(mem, e_HL2));
}
bool monitor_breakpoint_check_checkpoint(MEMSPACE mem, WORD addr,
break_list_t *list)
{
break_list_t *ptr;
breakpoint_t *bp;
bool result = FALSE;
MON_ADDR temp;
const char *type;
ptr = search_checkpoint_list(list, addr);
while (ptr && mon_is_in_range(ptr->brkpt->start_addr,
ptr->brkpt->end_addr, addr)) {
bp = ptr->brkpt;
ptr = ptr->next;
if (bp && bp->enabled==e_ON) {
/* If condition test fails, skip this checkpoint */
if (bp->condition) {
if (!mon_evaluate_conditional(bp->condition)) {
continue;
}
}
/* Check if the user specified some ignores */
if (bp->ignore_count) {
bp->ignore_count--;
continue;
}
bp->hit_count++;
result = TRUE;
temp = new_addr(mem,
(monitor_cpu_type.mon_register_get_val)(mem, e_PC)); if (bp->trace) {
type = "Trace";
result = FALSE;
}
else if (bp->watch_load)
type = "Watch-load";
else if (bp->watch_store)
type = "Watch-store";
else
type = "Break";
/*archdep_open_monitor_console(&mon_input, &mon_output);*/
mon_out("#%d (%s) ", bp->brknum, type);
mon_disassemble_instr(temp);
if (bp->command) {
mon_out("Executing: %s\n", bp->command);
parse_and_execute_line(bp->command);
}
if (bp->temporary)
mon_breakpoint_delete_checkpoint(bp->brknum);
}
}
return result;
}
static int freezeframe_dump(void)
{
mon_out("$8000-$9FFF ROM: %s", (freezeframe_rom_8000) ? "enabled" : "disabled");
mon_out("$E000-$FFFF ROM: %s", (freezeframe_rom_e000) ? "enabled" : "disabled");
return 0;
}
static int plus256k_dump(void)
{
mon_out("$0000-$0FFF bank: %d\n", plus256k_low_bank);
mon_out("$1000-$FFFF bank: %d\n", plus256k_high_bank);
mon_out("VICII-bank : %d\n", plus256k_video_bank);
mon_out("Register protection: %s\n", (plus256k_protected) ? "on" : "off");
return 0;
}
static int REGPARM1 vic_fp_mon_dump(void)
{
mon_out("I/O2 %sabled\n", cfg_en_flop ? "en" : "dis");
mon_out("BLK5 is R%cM %s\n", ram5_flop ? 'A' : 'O', CART_CFG_BLK5_WP ? "(write protected)" : "");
mon_out("BLK1 %sabled\n", blk1_en_flop ? "en" : "dis");
mon_out("RAM123 %sabled\n", ram123_en_flop ? "en" : "dis");
mon_out("ROM bank $%03x, offset $%06x\n", cart_rom_bank, cart_rom_bank << 13);
return 0;
}
void mon_breakpoint_set_ignore_count(int breakpt_num, int count)
{
breakpoint_t *bp;
bp = find_checkpoint(breakpt_num);
if (!bp) {
mon_out("#%d not a valid breakpoint\n", breakpt_num);
} else {
bp->ignore_count = count;
mon_out("Ignoring the next %d crossings of breakpoint #%d\n",
count, breakpt_num);
}
}
void mon_breakpoint_switch_checkpoint(int op, int breakpt_num)
{
breakpoint_t *bp;
bp = find_checkpoint(breakpt_num);
if (!bp) {
mon_out("#%d not a valid breakpoint\n", breakpt_num);
} else {
bp->enabled = op;
mon_out("Set breakpoint #%d to state: %s\n",
breakpt_num, (op == e_ON) ? "enabled" : "disabled");
}
}
void mon_breakpoint_set_checkpoint_command(int cp_num, char *cmd)
{
checkpoint_t *bp;
bp = find_checkpoint(cp_num);
if (!bp) {
mon_out("#%d not a valid checkpoint\n", cp_num);
} else {
bp->command = cmd;
mon_out("Setting checkpoint %d command to: %s\n",
cp_num, cmd);
}
}
void mon_breakpoint_switch_checkpoint(int op, int cp_num)
{
checkpoint_t *cp;
cp = find_checkpoint(cp_num);
if (!cp) {
mon_out("#%d not a valid checkpoint\n", cp_num);
} else {
cp->enabled = op;
mon_out("Set checkpoint #%d to state: %s\n",
cp_num, (op == e_ON) ? "enabled" : "disabled");
}
}
void mon_breakpoint_set_ignore_count(int cp_num, int count)
{
checkpoint_t *cp;
cp = find_checkpoint(cp_num);
if (!cp) {
mon_out("#%d not a valid checkpoint\n", cp_num);
} else {
cp->ignore_count = count;
mon_out("Will ignore the next %d hits of checkpoint #%d\n",
count, cp_num);
}
}
void mon_breakpoint_delete_checkpoint(int brknum)
{
int i;
breakpoint_t *bp = NULL;
MEMSPACE mem;
if (brknum == -1) {
/* Add user confirmation here. */
mon_out("Deleting all breakpoints\n");
for (i = 1; i < breakpoint_count; i++) {
bp = find_checkpoint(i);
if (bp)
mon_breakpoint_delete_checkpoint(i);
}
}
else if (!(bp = find_checkpoint(brknum))) {
mon_out("#%d not a valid breakpoint\n", brknum);
return;
} else {
mem = addr_memspace(bp->start_addr);
if (!(bp->watch_load) && !(bp->watch_store)) {
remove_checkpoint_from_list(&(breakpoints[mem]), bp);
if (!any_breakpoints(mem)) {
monitor_mask[mem] &= ~MI_BREAK;
if (!monitor_mask[mem])
interrupt_monitor_trap_off(mon_interfaces[mem]->int_status); }
} else {
if (bp->watch_load)
remove_checkpoint_from_list(&(watchpoints_load[mem]), bp);
if (bp->watch_store)
remove_checkpoint_from_list(&(watchpoints_store[mem]), bp);
if (!any_watchpoints(mem)) {
monitor_mask[mem] &= ~MI_WATCH;
mon_interfaces[mem]->toggle_watchpoints_func(0,
mon_interfaces[mem]->context);
if (!monitor_mask[mem])
interrupt_monitor_trap_off(mon_interfaces[mem]->int_status); }
}
}
if (bp != NULL) {
mon_delete_conditional(bp->condition);
if (bp->command)
lib_free(bp->command);
}
}
void mon_memory_hunt(MON_ADDR start_addr, MON_ADDR end_addr,
unsigned char *data)
{
BYTE *buf;
WORD start, next_read;
MEMSPACE mem;
unsigned int i;
int len;
len = mon_evaluate_address_range(&start_addr, &end_addr, TRUE, -1);
if (len < 0 || len < (int)(data_buf_len)) {
mon_out("Invalid range.\n");
return;
}
mem = addr_memspace(start_addr);
start = addr_location(start_addr);
buf = lib_malloc(sizeof(BYTE) * data_buf_len);
/* Fill buffer */
for (i = 0; i < data_buf_len; i++) {
buf[i] = mon_get_mem_val(mem, (WORD)ADDR_LIMIT(start + i));
}
/* Do compares */
next_read = start + (WORD)data_buf_len;
for (i = 0; i <= (len - data_buf_len); i++, next_read++) {
int not_found = 0;
unsigned int j;
for (j = 0; j < data_buf_len; j++) {
if ((buf[j] & data_mask_buf[j]) != data_buf[j]) {
not_found = 1;
break;
}
}
if (!not_found) {
mon_out("%04x\n", ADDR_LIMIT(start + i));
}
if (data_buf_len > 1) {
memmove(&(buf[0]), &(buf[1]), data_buf_len - 1);
}
buf[data_buf_len - 1] = mon_get_mem_val(mem, next_read);
}
mon_clear_buffer();
lib_free(buf);
}
void mon_disassemble_with_regdump(MEMSPACE mem, unsigned int addr)
{
monitor_cpu_type_t *monitor_cpu;
const char *dis_inst;
unsigned opc_size;
monitor_cpu = monitor_cpu_for_memspace[mem];
dis_inst = mon_disassemble_instr_interal(&opc_size, addr);
if (monitor_cpu->mon_register_print_ex) {
mon_out("%-35s - %s ", dis_inst, monitor_cpu->mon_register_print_ex(mem));
} else {
mon_out("%s ", dis_inst);
}
mon_stopwatch_show("", "\n");
}
void mon_memory_move(MON_ADDR start_addr, MON_ADDR end_addr, MON_ADDR dest)
{
unsigned int i, dst;
int len;
WORD start;
MEMSPACE src_mem, dest_mem;
BYTE *buf;
len = mon_evaluate_address_range(&start_addr, &end_addr, TRUE, -1);
if (len <= 0) {
mon_out("Invalid range.\n");
return;
}
src_mem = addr_memspace(start_addr);
start = addr_location(start_addr);
mon_evaluate_default_addr(&dest);
dst = addr_location(dest);
dest_mem = addr_memspace(dest);
buf = lib_malloc(sizeof(BYTE) * len);
for (i = 0; (int)i < len; i++) {
buf[i] = mon_get_mem_val(src_mem, (WORD)ADDR_LIMIT(start + i));
}
for (i = 0; (int)i < len; i++) {
mon_set_mem_val(dest_mem, (WORD)ADDR_LIMIT(dst + i), buf[i]);
}
lib_free(buf);
}
static int ross_dump(void)
{
mon_out("Size: %s, bank: %d\n",
(ross_is_32k) ? "32Kb" : "16Kb",
currbank);
return 0;
}
void mon_breakpoint_set_checkpoint_condition(int brk_num,
cond_node_t *cnode)
{
breakpoint_t *bp;
bp = find_checkpoint(brk_num);
if (!bp) {
mon_out("#%d not a valid breakpoint\n", brk_num);
} else {
bp->condition = cnode;
mon_out("Setting breakpoint %d condition to: ", brk_num);
mon_print_conditional(cnode);
mon_out("\n");
}
}
void mon_drive_list(int drive_number)
{
const char *name;
image_contents_t *listing;
vdrive_t *vdrive;
if ((drive_number < 8) || (drive_number > 11)) {
drive_number = 8;
}
vdrive = file_system_get_vdrive(drive_number);
if (vdrive == NULL || vdrive->image == NULL) {
mon_out("Drive %i not ready.\n", drive_number);
return;
}
name = disk_image_name_get(vdrive->image);
listing = diskcontents_read(name, drive_number);
if (listing != NULL) {
char *string = image_contents_to_string(listing, 1);
image_contents_file_list_t *element = listing->file_list;
mon_out("%s\n", string);
lib_free(string);
if (element == NULL) {
mon_out("Empty image\n");
} else {
do {
string = image_contents_file_to_string(element, 1);
mon_out("%s\n", string);
lib_free(string);
}
while ((element = element->next) != NULL);
}
if (listing->blocks_free >= 0) {
string = lib_msprintf("%d blocks free.\n", listing->blocks_free);
mon_out("%s", string);
lib_free(string);
}
}
}
static int easyflash_io1_dump(void)
{
mon_out("Mode %i, LED %s, jumper %s\n",
easyflash_memconfig[(easyflash_jumper << 3) | (easyflash_register_02 & 0x07)],
(easyflash_register_02 & 0x80) ? "on" : "off",
easyflash_jumper ? "on" : "off");
return 0;
}
static int finalexpansion_mon_dump(void)
{
BYTE mode;
int blk, active, ro;
mode = register_a & REGA_MODE_MASK;
mon_out("Register A: $%02x, B: $%02x, lock bit %i\n", register_a, register_b, lock_bit);
mon_out("Mode: %s\n", finalexpansion_mode_name[mode >> 5]);
/* BLK 0 */
mon_out("BLK 0: ");
active = 0;
ro = 0;
if (!(register_b & REGB_BLK0_OFF)) {
switch (mode) {
case MODE_SUPER_ROM:
case MODE_SUPER_RAM:
active = 1;
break;
case MODE_ROM_RAM:
case MODE_RAM1:
case MODE_RAM2:
active = 1;
ro = register_a & REGA_BLK0_RO;
break;
default:
break;
}
}
if (active) {
mon_out("RAM%s (offset $%06x)\n", ro ? " (read only)" : "", calc_addr(0, 0, BLK0_BASE));
} else {
mon_out("off\n");
}
/* BLK 1, 2, 3, 5 */
for (blk = 1; blk <= 5; blk++) {
finalexpansion_mon_dump_blk(blk);
}
return 0;
}
static int tfe_dump(void)
{
mon_out("CS8900 mapped to $%04x ($%04x-$%04x).\n",
tfe_current_device->start_address & ~tfe_current_device->address_mask,
tfe_current_device->start_address,
tfe_current_device->end_address);
return cs8900_dump();
}
void mon_breakpoint_set_checkpoint_condition(int cp_num,
cond_node_t *cnode)
{
checkpoint_t *cp;
if (cnode) {
cp = find_checkpoint(cp_num);
if (!cp) {
mon_out("#%d not a valid checkpoint\n", cp_num);
} else {
cp->condition = cnode;
mon_out("Setting checkpoint %d condition to: ", cp_num);
mon_print_conditional(cnode);
mon_out("\n");
}
}
}
static int ethernetcart_dump(void)
{
mon_out("CS8900 mapped to $%04x ($%04x-$%04x), Mode: %s.\n",
ethernetcart_device.start_address & ~ethernetcart_device.address_mask,
ethernetcart_device.start_address + (ethernetcart_mode ? 2 : 0),
ethernetcart_device.end_address,
ethernetcart_mode ? "RR-Net" : "TFE" );
return cs8900io_dump();
}
void mon_breakpoint_delete_checkpoint(int cp_num)
{
int i;
checkpoint_t *cp = NULL;
if (cp_num == -1) {
/* Add user confirmation here. */
mon_out("Deleting all checkpoints\n");
for (i = 1; i < breakpoint_count; i++) {
if ((cp = find_checkpoint(i))) {
remove_checkpoint(cp);
}
}
} else if (!(cp = find_checkpoint(cp_num))) {
mon_out("#%d not a valid checkpoint\n", cp_num);
return;
} else {
remove_checkpoint(cp);
}
}
static int make_offset_mode(int offset)
{
if (offset >= -16 && offset < 16) {
return offset & 0x1F;
} else if (offset >= -128 && offset < 128) {
return 0x80 | ASM_ADDR_MODE_INDEXED_OFF8;
} else if (offset >= -32768 && offset < 32768) {
return 0x80 | ASM_ADDR_MODE_INDEXED_OFF16;
} else {
mon_out("offset too large even for 16 bits (signed)\n");
return 0x80 | ASM_ADDR_MODE_INDEXED_OFF16;
}
}
int e888_dump(void)
{
if (pethre_enabled) {
char *s = "";
if (reg_E888 != 0x0F && reg_E888 != 0x83) {
s = "(unusual value) ";
}
mon_out("e888 = %02x %sramON = %d\n", reg_E888, s, petmem_ramON);
return 0;
}
return -1;
}
unsigned mon_disassemble_instr(MON_ADDR addr)
{
MEMSPACE mem;
WORD loc;
char *label;
unsigned opc_size;
mem = addr_memspace(addr);
loc = addr_location(addr);
/* Print the label for this location - if we have one */
label = mon_symbol_table_lookup_name(mem, loc);
if (label) {
mon_out(".%s:%04x %s:\n", mon_memspace_string[mem], loc, label);
}
/* Print the disassembled instruction */
mon_out("%s\n", mon_disassemble_instr_interal(&opc_size, addr));
return opc_size;
/* asm_addr_mode_get_size(asm_opcode_info_get(op)->addr_mode); */
}
/* display binary data (sprites/chars) */
void mon_memory_display_data(MON_ADDR start_addr, MON_ADDR end_addr,
unsigned int x, unsigned int y)
{
unsigned i, j, len, cnt = 0;
WORD addr = 0;
MEMSPACE mem;
len = mon_evaluate_address_range(&start_addr, &end_addr, FALSE,
(WORD)((x * y) / 8));
mem = addr_memspace(start_addr);
addr = addr_location(start_addr);
while (cnt < len) {
for (i = 0; i < y; i++) {
mon_out(">%s:%04x ", mon_memspace_string[mem], addr);
for (j = 0; j < (x / 8); j++) {
mon_print_bin(mon_get_mem_val(mem,
(WORD)(ADDR_LIMIT(addr + j))), '.', '*');
cnt++;
}
mon_out("\n");
addr = ADDR_LIMIT(addr + (x / 8));
if (mon_stop_output != 0) {
break;
}
}
mon_out("\n");
if (mon_stop_output != 0) {
break;
}
}
if ((x == 24) && (y == 21)) {
addr++; /* continue at next even address when showing sprites */
}
set_addr_location(&(dot_addr[mem]), addr);
}
