src/osd/sdl/debugwin.c
| r3563 | r3564 | |
| 2 | 2 | // |
| 3 | 3 | // debugwin.c - SDL/GTK+ debug window handling |
| 4 | 4 | // |
| 5 | | // Copyright (c) 1996-2007, Nicola Salmoria and the MAME Team. |
| 5 | // Copyright (c) 1996-2009, Nicola Salmoria and the MAME Team. |
| 6 | 6 | // Visit http://mamedev.org for licensing and usage restrictions. |
| 7 | 7 | // |
| 8 | 8 | // SDLMAME by Olivier Galibert and R. Belmont |
| r3563 | r3564 | |
| 14 | 14 | #include <gdk/gdkkeysyms.h> |
| 15 | 15 | #include <gtk/gtk.h> |
| 16 | 16 | |
| 17 | #include "dview.h" |
| 17 | 18 | #include "debug-intf.h" |
| 18 | 19 | #include "debug-sup.h" |
| 19 | 20 | #include "debug-cb.h" |
| 20 | 21 | |
| 21 | | #include "dview.h" |
| 22 | | #include "deprecat.h" |
| 23 | | |
| 24 | 22 | typedef struct hentry { |
| 25 | 23 | struct hentry *h; |
| 26 | 24 | char *e; |
| r3563 | r3564 | |
| 31 | 29 | struct hentry *h, *ch; |
| 32 | 30 | char *hold; |
| 33 | 31 | int keep_last; |
| 34 | | void (*cb)(const char *, void *); |
| 32 | void (*cb)(running_machine *,const char *, void *); |
| 35 | 33 | void *cbp; |
| 34 | running_machine *machine; |
| 36 | 35 | } edit; |
| 37 | 36 | |
| 38 | 37 | typedef struct { |
| r3563 | r3564 | |
| 43 | 42 | debug_view *disasm; |
| 44 | 43 | debug_view *registers; |
| 45 | 44 | int cpu; |
| 45 | running_machine *machine; |
| 46 | 46 | } debugmain_i; |
| 47 | 47 | |
| 48 | 48 | typedef struct memorywin_i { |
| r3563 | r3564 | |
| 52 | 52 | edit ed; |
| 53 | 53 | GtkComboBox *zone_w; |
| 54 | 54 | debug_view *memory; |
| 55 | running_machine *machine; |
| 55 | 56 | } memorywin_i; |
| 56 | 57 | |
| 57 | 58 | typedef struct disasmwin_i { |
| r3563 | r3564 | |
| 61 | 62 | edit ed; |
| 62 | 63 | GtkComboBox *cpu_w; |
| 63 | 64 | debug_view *disasm; |
| 65 | running_machine *machine; |
| 64 | 66 | } disasmwin_i; |
| 65 | 67 | |
| 66 | 68 | typedef struct logwin_i { |
| r3563 | r3564 | |
| 68 | 70 | GtkWidget *win; |
| 69 | 71 | DView *log_w; |
| 70 | 72 | debug_view *log; |
| 73 | running_machine *machine; |
| 71 | 74 | } logwin_i; |
| 72 | 75 | |
| 73 | 76 | typedef struct memorycombo_item |
| r3563 | r3564 | |
| 81 | 84 | UINT8 offset_xor; |
| 82 | 85 | UINT8 little_endian; |
| 83 | 86 | UINT8 prefsize; |
| 87 | running_machine *machine; |
| 84 | 88 | } memorycombo_item; |
| 85 | 89 | |
| 86 | 90 | |
| r3563 | r3564 | |
| 91 | 95 | |
| 92 | 96 | static memorycombo_item *memorycombo; |
| 93 | 97 | |
| 94 | | static void debugmain_init(void); |
| 98 | static void debugmain_init(running_machine *machine); |
| 95 | 99 | |
| 96 | 100 | static void debugwin_show(int show) |
| 97 | 101 | { |
| r3563 | r3564 | |
| 125 | 129 | // first add all the CPUs' address spaces |
| 126 | 130 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 127 | 131 | { |
| 128 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 129 | | if (cpuinfo->valid) |
| 132 | if (machine->cpu[cpunum] != NULL) |
| 133 | { |
| 134 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(machine->cpu[cpunum]); |
| 135 | |
| 130 | 136 | for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++) |
| 137 | { |
| 131 | 138 | if (cpuinfo->space[spacenum].databytes) |
| 132 | 139 | { |
| 133 | 140 | memorycombo_item *ci = malloc_or_die(sizeof(*ci)); |
| 134 | 141 | memset(ci, 0, sizeof(*ci)); |
| 135 | 142 | ci->cpunum = cpunum; |
| 136 | 143 | ci->spacenum = spacenum; |
| 144 | ci->machine = machine; |
| 137 | 145 | ci->prefsize = MIN(cpuinfo->space[spacenum].databytes, 8); |
| 138 | 146 | |
| 139 | | snprintf(ci->name, ARRAY_LENGTH(ci->name), "CPU #%d \"%s\" (%s) %s memory", cpunum, machine->config->cpu[cpunum].tag, cpunum_name(cpunum), address_space_names[spacenum]); |
| 147 | snprintf(ci->name, ARRAY_LENGTH(ci->name), "CPU #%d \"%s\" (%s) %s memory", cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum]), address_space_names[spacenum]); |
| 140 | 148 | |
| 141 | 149 | *tail = ci; |
| 142 | 150 | tail = &ci->next; |
| 143 | 151 | } |
| 152 | } |
| 153 | } |
| 144 | 154 | } |
| 145 | 155 | |
| 146 | 156 | // then add all the memory regions |
| r3563 | r3564 | |
| 157 | 167 | ci->prefsize = MIN(width, 8); |
| 158 | 168 | ci->offset_xor = width - 1; |
| 159 | 169 | ci->little_endian = little_endian; |
| 170 | ci->machine = machine; |
| 160 | 171 | |
| 161 | 172 | snprintf(ci->name, ARRAY_LENGTH(ci->name), "Region \"%s\"", rgntag); |
| 162 | 173 | |
| r3563 | r3564 | |
| 185 | 196 | ci->length = valcount * valsize; |
| 186 | 197 | ci->prefsize = MIN(valsize, 8); |
| 187 | 198 | ci->little_endian = TRUE; |
| 199 | ci->machine = machine; |
| 188 | 200 | strcpy(ci->name, strrchr(name, '/') + 1); |
| 189 | 201 | *tail = ci; |
| 190 | 202 | tail = &ci->next; |
| r3563 | r3564 | |
| 225 | 237 | edit *e = user_data; |
| 226 | 238 | const char *text = gtk_entry_get_text(e->edit_w); |
| 227 | 239 | edit_add_hist(e, text); |
| 228 | | e->cb(text, e->cbp); |
| 240 | e->cb(e->machine, text, e->cbp); |
| 229 | 241 | edit_set_field(e); |
| 230 | 242 | |
| 231 | 243 | } |
| r3563 | r3564 | |
| 283 | 295 | |
| 284 | 296 | static gboolean edit_key(GtkWidget *item, GdkEventKey *k, gpointer user_data) |
| 285 | 297 | { |
| 298 | edit *e = (edit *)user_data; |
| 299 | |
| 286 | 300 | switch(k->keyval) { |
| 287 | 301 | case GDK_Up: |
| 288 | | edit_hist_back((edit *)user_data); |
| 302 | edit_hist_back(e); |
| 289 | 303 | return TRUE; |
| 290 | 304 | case GDK_Down: |
| 291 | | edit_hist_forward((edit *)user_data); |
| 305 | edit_hist_forward(e); |
| 292 | 306 | return TRUE; |
| 293 | 307 | } |
| 294 | 308 | return FALSE; |
| 295 | 309 | } |
| 296 | 310 | |
| 297 | | static void edit_init(edit *e, GtkWidget *w, const char *ft, int kl, void (*cb)(const char *, void *), void *cbp) |
| 311 | static void edit_init(running_machine *machine, edit *e, GtkWidget *w, const char *ft, int kl, void (*cb)(running_machine *, const char *, void *), void *cbp) |
| 298 | 312 | { |
| 299 | 313 | e->edit_w = GTK_ENTRY(w); |
| 300 | 314 | e->h = 0; |
| r3563 | r3564 | |
| 303 | 317 | e->keep_last = kl; |
| 304 | 318 | e->cb = cb; |
| 305 | 319 | e->cbp = cbp; |
| 320 | e->machine = machine; |
| 306 | 321 | if(ft) |
| 307 | 322 | edit_add_hist(e, ft); |
| 308 | 323 | edit_set_field(e); |
| r3563 | r3564 | |
| 370 | 385 | debug_view_set_property_UINT32(dmain->registers, DVP_REGS_CPUNUM, cpunum); |
| 371 | 386 | |
| 372 | 387 | // then update the caption |
| 373 | | sprintf(title, "Debug: %s - CPU #%d \"%s\" (%s)", machine->gamedrv->name, cpunum, machine->config->cpu[cpunum].tag, cpunum_name(cpunum)); |
| 388 | sprintf(title, "Debug: %s - CPU #%d \"%s\" (%s)", machine->gamedrv->name, cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum])); |
| 374 | 389 | gtk_window_set_title(GTK_WINDOW(dmain->win), title); |
| 375 | 390 | debugmain_update_checks(dmain); |
| 376 | 391 | } |
| r3563 | r3564 | |
| 385 | 400 | if(!dmain) { |
| 386 | 401 | // GTK init should probably be done earlier |
| 387 | 402 | gtk_init(0, 0); |
| 388 | | debugmain_init(); |
| 403 | debugmain_init(machine); |
| 389 | 404 | } |
| 390 | 405 | |
| 391 | 406 | // update the views in the console to reflect the current CPU |
| 392 | | debugmain_set_cpunum(machine, cpu_getactivecpu()); |
| 407 | debugmain_set_cpunum(machine, cpunum_get_active()); |
| 393 | 408 | |
| 394 | 409 | debugwin_show(1); |
| 395 | 410 | gtk_main_iteration(); |
| r3563 | r3564 | |
| 401 | 416 | gtk_main_iteration_do(FALSE); |
| 402 | 417 | } |
| 403 | 418 | |
| 404 | | static void debugmain_process_string(const char *str, void *dmp) |
| 419 | static void debugmain_process_string(running_machine *machine, const char *str, void *dmp) |
| 405 | 420 | { |
| 406 | 421 | if(!str[0]) |
| 407 | | debug_cpu_single_step(1); |
| 422 | debug_cpu_single_step(machine, 1); |
| 408 | 423 | else |
| 409 | | debug_console_execute_command(Machine, str, 1); |
| 424 | debug_console_execute_command(machine, str, 1); |
| 410 | 425 | } |
| 411 | 426 | |
| 412 | 427 | static void debugmain_destroy(GtkObject *obj, gpointer user_data) |
| 413 | 428 | { |
| 414 | | mame_schedule_exit(Machine); |
| 429 | debugmain_i *dmain = (debugmain_i *)user_data; |
| 430 | |
| 431 | mame_schedule_exit(dmain->machine); |
| 415 | 432 | } |
| 416 | 433 | |
| 417 | | static void debugmain_init(void) |
| 434 | static void debugmain_init(running_machine *machine) |
| 418 | 435 | { |
| 419 | 436 | dmain = malloc(sizeof(*dmain)); |
| 420 | 437 | memset(dmain, 0, sizeof(*dmain)); |
| 421 | | dmain->win = create_debugmain(); |
| 438 | dmain->win = create_debugmain(machine); |
| 422 | 439 | dmain->cpu = -1; |
| 440 | dmain->machine = machine; |
| 423 | 441 | |
| 424 | 442 | dmain->console_w = DVIEW(lookup_widget(dmain->win, "console")); |
| 425 | 443 | dmain->disasm_w = DVIEW(lookup_widget(dmain->win, "disasm")); |
| 426 | 444 | dmain->registers_w = DVIEW(lookup_widget(dmain->win, "registers")); |
| 427 | 445 | |
| 428 | | dmain->console = debug_view_alloc(DVT_CONSOLE); |
| 429 | | dmain->disasm = debug_view_alloc(DVT_DISASSEMBLY); |
| 430 | | dmain->registers = debug_view_alloc(DVT_REGISTERS); |
| 446 | dmain->console = debug_view_alloc(machine, DVT_CONSOLE); |
| 447 | dmain->disasm = debug_view_alloc(machine, DVT_DISASSEMBLY); |
| 448 | dmain->registers = debug_view_alloc(machine, DVT_REGISTERS); |
| 431 | 449 | |
| 432 | 450 | dview_set_debug_view(dmain->console_w, dmain->console); |
| 433 | 451 | dview_set_debug_view(dmain->disasm_w, dmain->disasm); |
| r3563 | r3564 | |
| 435 | 453 | |
| 436 | 454 | dview_this_one_is_stupidly_autoscrolling(dmain->console_w); |
| 437 | 455 | |
| 438 | | edit_init(&dmain->ed, lookup_widget(dmain->win, "edit"), 0, 0, debugmain_process_string, &dmain); |
| 456 | edit_init(machine, &dmain->ed, lookup_widget(dmain->win, "edit"), 0, 0, debugmain_process_string, &dmain); |
| 439 | 457 | |
| 440 | 458 | debug_view_begin_update(dmain->disasm); |
| 441 | 459 | debug_view_set_property_string(dmain->disasm, DVP_DASM_EXPRESSION, "curpc"); |
| 442 | 460 | debug_view_set_property_UINT32(dmain->disasm, DVP_DASM_TRACK_LIVE, 1); |
| 443 | 461 | debug_view_end_update(dmain->disasm); |
| 444 | 462 | |
| 445 | | g_signal_connect(dmain->win, "destroy", G_CALLBACK(debugmain_destroy), 0); |
| 463 | g_signal_connect(dmain->win, "destroy", G_CALLBACK(debugmain_destroy), dmain); |
| 446 | 464 | g_signal_connect(lookup_widget(dmain->win, "raw_opcodes"), "activate", G_CALLBACK(debugmain_raw_opcodes_activate), dmain); |
| 447 | 465 | g_signal_connect(lookup_widget(dmain->win, "enc_opcodes"), "activate", G_CALLBACK(debugmain_enc_opcodes_activate), dmain); |
| 448 | 466 | g_signal_connect(lookup_widget(dmain->win, "comments"), "activate", G_CALLBACK(debugmain_comments_activate), dmain); |
| r3563 | r3564 | |
| 483 | 501 | memorywin_update_selection(mem, ci); |
| 484 | 502 | } |
| 485 | 503 | |
| 486 | | static void memorywin_process_string(const char *str, void *memp) |
| 504 | static void memorywin_process_string(running_machine *machine, const char *str, void *memp) |
| 487 | 505 | { |
| 488 | 506 | memorywin_i *mem = memp; |
| 489 | 507 | debug_view_set_property_string(mem->memory, DVP_MEM_EXPRESSION, str); |
| r3563 | r3564 | |
| 506 | 524 | static void memorywin_new(running_machine *machine) |
| 507 | 525 | { |
| 508 | 526 | memorywin_i *mem; |
| 509 | | int item, cursel, curcpu = cpu_getactivecpu(); |
| 527 | int item, cursel, curcpu = cpunum_get_active(); |
| 510 | 528 | memorycombo_item *ci, *selci = NULL; |
| 511 | 529 | |
| 512 | 530 | mem = malloc(sizeof(*mem)); |
| 513 | 531 | memset(mem, 0, sizeof(*mem)); |
| 514 | 532 | mem->next = memorywin_list; |
| 515 | 533 | memorywin_list = mem; |
| 516 | | mem->win = create_memorywin(); |
| 534 | mem->win = create_memorywin(machine); |
| 535 | mem->machine = machine; |
| 517 | 536 | |
| 518 | 537 | mem->memory_w = DVIEW(lookup_widget(mem->win, "memoryview")); |
| 519 | 538 | mem->zone_w = GTK_COMBO_BOX(lookup_widget(mem->win, "zone")); |
| 520 | 539 | |
| 521 | | mem->memory = debug_view_alloc(DVT_MEMORY); |
| 540 | mem->memory = debug_view_alloc(machine, DVT_MEMORY); |
| 522 | 541 | |
| 523 | 542 | dview_set_debug_view(mem->memory_w, mem->memory); |
| 524 | 543 | |
| 525 | | edit_init(&mem->ed, lookup_widget(mem->win, "edit"), "0", 1, memorywin_process_string, mem); |
| 544 | edit_init(machine, &mem->ed, lookup_widget(mem->win, "edit"), "0", 1, memorywin_process_string, mem); |
| 526 | 545 | |
| 527 | 546 | debug_view_begin_update(mem->memory); |
| 528 | 547 | debug_view_set_property_string(mem->memory, DVP_MEM_EXPRESSION, "0"); |
| r3563 | r3564 | |
| 578 | 597 | |
| 579 | 598 | disasmwin_update_checks(info); |
| 580 | 599 | |
| 581 | | sprintf(title, "Disassembly: CPU #%d \"%s\" (%s)", cpunum, Machine->config->cpu[cpunum].tag, cpunum_name(cpunum)); |
| 600 | sprintf(title, "Disassembly: CPU #%d \"%s\" (%s)", cpunum, info->machine->config->cpu[cpunum].tag, cpu_get_name(info->machine->cpu[cpunum])); |
| 582 | 601 | gtk_window_set_title(GTK_WINDOW(info->win), title); |
| 583 | 602 | } |
| 584 | 603 | |
| r3563 | r3564 | |
| 589 | 608 | item = 0; |
| 590 | 609 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 591 | 610 | { |
| 592 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 593 | | if (cpuinfo->valid) |
| 611 | if (dis->machine->cpu[cpunum] != NULL) |
| 612 | { |
| 613 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(dis->machine->cpu[cpunum]); |
| 614 | |
| 594 | 615 | if (cpuinfo->space[ADDRESS_SPACE_PROGRAM].databytes) |
| 595 | 616 | { |
| 596 | 617 | if(item == sel) { |
| r3563 | r3564 | |
| 599 | 620 | } |
| 600 | 621 | item++; |
| 601 | 622 | } |
| 623 | } |
| 602 | 624 | } |
| 603 | 625 | } |
| 604 | 626 | |
| r3563 | r3564 | |
| 632 | 654 | } |
| 633 | 655 | } |
| 634 | 656 | |
| 635 | | static void disasmwin_process_string(const char *str, void *disp) |
| 657 | static void disasmwin_process_string(running_machine *machine, const char *str, void *disp) |
| 636 | 658 | { |
| 637 | 659 | disasmwin_i *dis = disp; |
| 638 | 660 | debug_view_set_property_string(dis->disasm, DVP_DASM_EXPRESSION, str); |
| r3563 | r3564 | |
| 652 | 674 | free(dis); |
| 653 | 675 | } |
| 654 | 676 | |
| 655 | | static void disasmwin_new(void) |
| 677 | static void disasmwin_new(running_machine *machine) |
| 656 | 678 | { |
| 657 | 679 | disasmwin_i *dis; |
| 658 | | int cpunum, curcpu = cpu_getactivecpu(); |
| 680 | int cpunum, curcpu = cpunum_get_active(); |
| 659 | 681 | int item, citem; |
| 660 | 682 | |
| 661 | 683 | dis = malloc(sizeof(*dis)); |
| 662 | 684 | memset(dis, 0, sizeof(*dis)); |
| 663 | 685 | dis->next = disasmwin_list; |
| 664 | 686 | disasmwin_list = dis; |
| 665 | | dis->win = create_disasmwin(); |
| 687 | dis->win = create_disasmwin(machine); |
| 688 | dis->machine = machine; |
| 666 | 689 | |
| 667 | 690 | dis->disasm_w = DVIEW(lookup_widget(dis->win, "disasmview")); |
| 668 | 691 | dis->cpu_w = GTK_COMBO_BOX(lookup_widget(dis->win, "cpu")); |
| 669 | 692 | |
| 670 | | dis->disasm = debug_view_alloc(DVT_DISASSEMBLY); |
| 693 | dis->disasm = debug_view_alloc(machine, DVT_DISASSEMBLY); |
| 671 | 694 | |
| 672 | 695 | dview_set_debug_view(dis->disasm_w, dis->disasm); |
| 673 | 696 | |
| 674 | | edit_init(&dis->ed, lookup_widget(dis->win, "edit"), "curpc", 1, disasmwin_process_string, dis); |
| 697 | edit_init(machine, &dis->ed, lookup_widget(dis->win, "edit"), "curpc", 1, disasmwin_process_string, dis); |
| 675 | 698 | |
| 676 | 699 | debug_view_begin_update(dis->disasm); |
| 677 | 700 | debug_view_set_property_string(dis->disasm, DVP_DASM_EXPRESSION, "curpc"); |
| r3563 | r3564 | |
| 683 | 706 | citem = -1; |
| 684 | 707 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 685 | 708 | { |
| 686 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 687 | | if (cpuinfo->valid) |
| 709 | if (machine->cpu[cpunum] != NULL) |
| 710 | { |
| 711 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(machine->cpu[cpunum]); |
| 688 | 712 | if (cpuinfo->space[ADDRESS_SPACE_PROGRAM].databytes) |
| 689 | 713 | { |
| 690 | 714 | char name[100]; |
| 691 | | sprintf(name, "CPU #%d \"%s\" (%s)", cpunum, Machine->config->cpu[cpunum].tag, cpunum_name(cpunum)); |
| 715 | sprintf(name, "CPU #%d \"%s\" (%s)", cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum])); |
| 692 | 716 | gtk_combo_box_append_text(dis->cpu_w, name); |
| 693 | 717 | if(cpunum == curcpu) |
| 694 | 718 | citem = item; |
| 695 | 719 | item++; |
| 696 | 720 | } |
| 721 | } |
| 697 | 722 | } |
| 698 | 723 | |
| 699 | 724 | if(citem == -1) { |
| r3563 | r3564 | |
| 727 | 752 | free(log); |
| 728 | 753 | } |
| 729 | 754 | |
| 730 | | static void logwin_new(void) |
| 755 | static void logwin_new(running_machine *machine) |
| 731 | 756 | { |
| 732 | 757 | logwin_i *log; |
| 733 | 758 | |
| r3563 | r3564 | |
| 735 | 760 | memset(log, 0, sizeof(*log)); |
| 736 | 761 | log->next = logwin_list; |
| 737 | 762 | logwin_list = log; |
| 738 | | log->win = create_logwin(); |
| 763 | log->win = create_logwin(machine); |
| 764 | log->machine = machine; |
| 739 | 765 | |
| 740 | 766 | log->log_w = DVIEW(lookup_widget(log->win, "logview")); |
| 741 | 767 | |
| 742 | | log->log = debug_view_alloc(DVT_LOG); |
| 768 | log->log = debug_view_alloc(machine, DVT_LOG); |
| 743 | 769 | |
| 744 | 770 | dview_this_one_is_stupidly_autoscrolling(log->log_w); |
| 745 | 771 | dview_set_debug_view(log->log_w, log->log); |
| r3563 | r3564 | |
| 750 | 776 | |
| 751 | 777 | void on_new_mem_activate(GtkMenuItem *item, gpointer user_data) |
| 752 | 778 | { |
| 753 | | memorywin_new(Machine); |
| 779 | memorywin_new((running_machine *)user_data); |
| 754 | 780 | } |
| 755 | 781 | |
| 756 | 782 | void on_new_disasm_activate(GtkMenuItem *item, gpointer user_data) |
| 757 | 783 | { |
| 758 | | disasmwin_new(); |
| 784 | disasmwin_new((running_machine *)user_data); |
| 759 | 785 | } |
| 760 | 786 | |
| 761 | 787 | void on_new_errorlog_activate(GtkMenuItem *item, gpointer user_data) |
| 762 | 788 | { |
| 763 | | logwin_new(); |
| 789 | logwin_new((running_machine *)user_data); |
| 764 | 790 | } |
| 765 | 791 | |
| 766 | 792 | void on_run_activate(GtkMenuItem *item, gpointer user_data) |
| 767 | 793 | { |
| 768 | | debug_cpu_go(~0); |
| 794 | debug_cpu_go((running_machine *)user_data, ~0); |
| 769 | 795 | } |
| 770 | 796 | |
| 771 | 797 | void on_run_h_activate(GtkMenuItem *item, gpointer user_data) |
| 772 | 798 | { |
| 773 | 799 | debugwin_show(0); |
| 774 | | debug_cpu_go(~0); |
| 800 | debug_cpu_go((running_machine *)user_data, ~0); |
| 775 | 801 | } |
| 776 | 802 | |
| 777 | 803 | void on_run_cpu_activate(GtkMenuItem *item, gpointer user_data) |
| 778 | 804 | { |
| 779 | | debug_cpu_next_cpu(); |
| 805 | debug_cpu_next_cpu((running_machine *)user_data); |
| 780 | 806 | } |
| 781 | 807 | |
| 782 | 808 | void on_run_irq_activate(GtkMenuItem *item, gpointer user_data) |
| 783 | 809 | { |
| 784 | | debug_cpu_go_interrupt(-1); |
| 810 | debug_cpu_go_interrupt((running_machine *)user_data, -1); |
| 785 | 811 | } |
| 786 | 812 | |
| 787 | 813 | void on_run_vbl_activate(GtkMenuItem *item, gpointer user_data) |
| 788 | 814 | { |
| 789 | | debug_cpu_go_vblank(); |
| 815 | debug_cpu_go_vblank((running_machine *)user_data); |
| 790 | 816 | } |
| 791 | 817 | |
| 792 | 818 | void on_step_into_activate(GtkMenuItem *item, gpointer user_data) |
| 793 | 819 | { |
| 794 | | debug_cpu_single_step(1); |
| 820 | debug_cpu_single_step((running_machine *)user_data, 1); |
| 795 | 821 | } |
| 796 | 822 | |
| 797 | 823 | void on_step_over_activate(GtkMenuItem *item, gpointer user_data) |
| 798 | 824 | { |
| 799 | | debug_cpu_single_step_over(1); |
| 825 | debug_cpu_single_step_over((running_machine *)user_data, 1); |
| 800 | 826 | } |
| 801 | 827 | |
| 802 | 828 | void on_step_out_activate(GtkMenuItem *item, gpointer user_data) |
| 803 | 829 | { |
| 804 | | debug_cpu_single_step_out(); |
| 830 | debug_cpu_single_step_out((running_machine *)user_data); |
| 805 | 831 | } |
| 806 | 832 | |
| 807 | 833 | void on_hard_reset_activate(GtkMenuItem *item, gpointer user_data) |
| 808 | 834 | { |
| 809 | | mame_schedule_hard_reset(Machine); |
| 835 | mame_schedule_hard_reset((running_machine *)user_data); |
| 810 | 836 | } |
| 811 | 837 | |
| 812 | 838 | void on_soft_reset_activate(GtkMenuItem *item, gpointer user_data) |
| 813 | 839 | { |
| 814 | | mame_schedule_soft_reset(Machine); |
| 815 | | debug_cpu_go(~0); |
| 840 | mame_schedule_soft_reset((running_machine *)user_data); |
| 841 | debug_cpu_go((running_machine *)user_data, ~0); |
| 816 | 842 | } |
| 817 | 843 | |
| 818 | 844 | void on_exit_activate(GtkMenuItem *item, gpointer user_data) |
| 819 | 845 | { |
| 820 | | mame_schedule_exit(Machine); |
| 846 | mame_schedule_exit((running_machine *)user_data); |
| 821 | 847 | } |
| 822 | 848 | |
| 823 | 849 | void on_chunks_1_activate(GtkMenuItem *item, gpointer user_data) |
src/osd/sdl/debugosx.c
| r3563 | r3564 | |
| 2 | 2 | // |
| 3 | 3 | // debugosx.c - MacOS X debug window handling |
| 4 | 4 | // |
| 5 | | // Copyright (c) 1996-2007, Nicola Salmoria and the MAME Team. |
| 5 | // Copyright (c) 1996-2008, Nicola Salmoria and the MAME Team. |
| 6 | 6 | // Visit http://mamedev.org for licensing and usage restrictions. |
| 7 | 7 | // |
| 8 | 8 | //============================================================ |
| r3563 | r3564 | |
| 40 | 40 | #include "window.h" |
| 41 | 41 | #include "video.h" |
| 42 | 42 | #include "config.h" |
| 43 | | #include "deprecat.h" |
| 44 | 43 | |
| 45 | 44 | #define OSX_POPUP_COMMAND 'popu' |
| 46 | | #define OSX_BASE_ID 'cmd0' |
| 45 | #define OSX_BASE_ID 'cmd0' |
| 47 | 46 | |
| 48 | 47 | enum |
| 49 | 48 | { |
| r3563 | r3564 | |
| 56 | 55 | KEY_F7 = 0x62, |
| 57 | 56 | KEY_F8 = 0x64, |
| 58 | 57 | KEY_F9 = 0x65, |
| 59 | | KEY_F10 = 0x6D, |
| 58 | KEY_F10 = 0x6D, |
| 60 | 59 | KEY_F11 = 0x67, |
| 61 | | KEY_F12 = 0x6F, |
| 60 | KEY_F12 = 0x6F, |
| 62 | 61 | KEY_F13 = 0x69, |
| 63 | 62 | KEY_F14 = 0x6B, |
| 64 | 63 | KEY_F15 = 0x71 |
| r3563 | r3564 | |
| 194 | 193 | |
| 195 | 194 | MenuRef contextualMenu; |
| 196 | 195 | HIViewRef contentView; |
| 196 | |
| 197 | running_machine *machine; |
| 197 | 198 | }; |
| 198 | 199 | |
| 199 | 200 | |
| r3563 | r3564 | |
| 247 | 248 | // PROTOTYPES |
| 248 | 249 | //============================================================ |
| 249 | 250 | |
| 250 | | static int debugwin_init_windows(void); |
| 251 | | static debugwin_info *debug_window_create(const char * title, void *unused); |
| 251 | static int debugwin_init_windows(running_machine *machine); |
| 252 | static debugwin_info *debug_window_create(running_machine *machine, const char * title, void *unused); |
| 252 | 253 | static void debug_window_free(debugwin_info *info); |
| 253 | 254 | static OSStatus debug_window_proc(EventHandlerCallRef inHandler, EventRef inEvent, void * inUserData); |
| 254 | 255 | |
| r3563 | r3564 | |
| 273 | 274 | static int memory_handle_command(debugwin_info *info, EventRef inEvent); |
| 274 | 275 | static int memory_handle_key(debugwin_info *info, EventRef inEvent); |
| 275 | 276 | |
| 276 | | static void disasm_create_window(void); |
| 277 | static void disasm_create_window(running_machine *machine); |
| 277 | 278 | static void disasm_recompute_children(debugwin_info *info); |
| 278 | 279 | static void disasm_process_string(debugwin_info *info, const char *string); |
| 279 | 280 | static void disasm_update_checkmarks(debugwin_info *info); |
| r3563 | r3564 | |
| 298 | 299 | // OSX stubs |
| 299 | 300 | //============================================================ |
| 300 | 301 | |
| 301 | | INLINE void osx_init_debugger( void ) |
| 302 | INLINE void osx_init_debugger(running_machine *machine) |
| 302 | 303 | { |
| 303 | 304 | if ( osx_inited_debugger == 0 ) |
| 304 | 305 | { |
| 305 | | if ( debugwin_init_windows() != 0 ) |
| 306 | if ( debugwin_init_windows(machine) != 0 ) |
| 306 | 307 | { |
| 307 | 308 | mame_printf_error( "Could not init debugger\n" ); |
| 308 | 309 | exit( -1 ); |
| r3563 | r3564 | |
| 371 | 372 | EventRef message; |
| 372 | 373 | EventTargetRef target = GetEventDispatcherTarget(); |
| 373 | 374 | |
| 374 | | osx_init_debugger(); |
| 375 | osx_init_debugger(machine); |
| 375 | 376 | |
| 376 | 377 | // create a console window |
| 377 | 378 | if (!main_console) |
| r3563 | r3564 | |
| 379 | 380 | |
| 380 | 381 | // update the views in the console to reflect the current CPU |
| 381 | 382 | if (main_console) |
| 382 | | console_set_cpunum(machine, cpu_getactivecpu()); |
| 383 | console_set_cpunum(machine, cpunum_get_active()); |
| 383 | 384 | |
| 384 | 385 | // make sure the debug windows are visible |
| 385 | 386 | waiting_for_debugger = TRUE; |
| r3563 | r3564 | |
| 403 | 404 | // debugwin_init_windows |
| 404 | 405 | //============================================================ |
| 405 | 406 | |
| 406 | | static int debugwin_init_windows(void) |
| 407 | static int debugwin_init_windows(running_machine *machine) |
| 407 | 408 | { |
| 408 | 409 | SInt32 val; |
| 409 | 410 | |
| r3563 | r3564 | |
| 483 | 484 | |
| 484 | 485 | void debugwin_update_during_game(running_machine *machine) |
| 485 | 486 | { |
| 486 | | osx_init_debugger(); |
| 487 | osx_init_debugger(machine); |
| 487 | 488 | |
| 489 | if (!machine->debugcpu_data) return; |
| 490 | |
| 488 | 491 | // if we're running live, do some checks |
| 489 | 492 | if ( ! debug_cpu_is_stopped(machine) ) |
| 490 | 493 | { |
| r3563 | r3564 | |
| 525 | 528 | // debug_window_create |
| 526 | 529 | //============================================================ |
| 527 | 530 | |
| 528 | | static debugwin_info *debug_window_create(const char *title, void *unused) |
| 531 | static debugwin_info *debug_window_create(running_machine *machine, const char *title, void *unused) |
| 529 | 532 | { |
| 530 | 533 | CGDirectDisplayID mainID = CGMainDisplayID(); |
| 531 | 534 | |
| r3563 | r3564 | |
| 541 | 544 | memset(info, 0, sizeof(*info)); |
| 542 | 545 | |
| 543 | 546 | info->wnd = NULL; |
| 547 | info->machine = machine; |
| 544 | 548 | |
| 545 | 549 | // create the window |
| 546 | 550 | work_bounds.top = work_bounds.left = 0; |
| r3563 | r3564 | |
| 796 | 800 | if (main_console && main_console->wnd == info->wnd) |
| 797 | 801 | { |
| 798 | 802 | smart_show_all(FALSE); |
| 799 | | debug_cpu_go(~0); |
| 803 | debug_cpu_go(info->machine, ~0); |
| 800 | 804 | return noErr; |
| 801 | 805 | } |
| 802 | 806 | |
| r3563 | r3564 | |
| 903 | 907 | SetControlProperty(view->vscroll, 'MAME', 'info', sizeof( view ), &view ); |
| 904 | 908 | |
| 905 | 909 | // create the debug view |
| 906 | | view->view = debug_view_alloc(type); |
| 910 | view->view = debug_view_alloc(info->machine, type); |
| 907 | 911 | if (!view->view) |
| 908 | 912 | goto cleanup; |
| 909 | 913 | |
| r3563 | r3564 | |
| 971 | 975 | viscols = debug_view_get_property_UINT32(view->view, DVP_VISIBLE_COLS); |
| 972 | 976 | viewdata = debug_view_get_property_ptr(view->view, DVP_VIEW_DATA); |
| 973 | 977 | |
| 978 | if (!viewdata) return; |
| 979 | |
| 974 | 980 | // set the font |
| 975 | 981 | CGContextSelectFont(dc, OSX_DEBUGGER_FONT_NAME, OSX_DEBUGGER_FONT_SIZE, kCGEncodingMacRoman); |
| 976 | 982 | CGContextSetTextDrawingMode(dc,kCGTextFill); |
| r3563 | r3564 | |
| 1833 | 1839 | return eventNotHandledErr; |
| 1834 | 1840 | } |
| 1835 | 1841 | |
| 1836 | | #if 0 |
| 1837 | | //============================================================ |
| 1838 | | // generic_create_window |
| 1839 | | //============================================================ |
| 1840 | 1842 | |
| 1841 | | static void generic_create_window(int type) |
| 1842 | | { |
| 1843 | | debugwin_info *info; |
| 1844 | | char title[256]; |
| 1845 | | Rect bounds; |
| 1846 | | |
| 1847 | | // create the window |
| 1848 | | snprintf(title, ARRAY_LENGTH(title), "Debug: %s [%s]", Machine->gamedrv->description, Machine->gamedrv->name); |
| 1849 | | info = debug_window_create(title, NULL); |
| 1850 | | if (!info || !debug_view_create(info, 0, type)) |
| 1851 | | return; |
| 1852 | | |
| 1853 | | // set the child function |
| 1854 | | info->recompute_children = generic_recompute_children; |
| 1855 | | |
| 1856 | | // recompute the children once to get the maxwidth |
| 1857 | | generic_recompute_children(info); |
| 1858 | | |
| 1859 | | // position the window and recompute children again |
| 1860 | | bounds.top = bounds.left = 100; |
| 1861 | | bounds.right = bounds.left + info->maxwidth; |
| 1862 | | bounds.bottom = bounds.top + 200; |
| 1863 | | |
| 1864 | | SetWindowBounds(info->wnd, kWindowStructureRgn, &bounds ); |
| 1865 | | ShowWindow(info->wnd); |
| 1866 | | SelectWindow(info->wnd); |
| 1867 | | |
| 1868 | | generic_recompute_children(info); |
| 1869 | | } |
| 1870 | | #endif |
| 1871 | | |
| 1872 | | |
| 1873 | 1843 | //============================================================ |
| 1874 | 1844 | // generic_recompute_children |
| 1875 | 1845 | //============================================================ |
| r3563 | r3564 | |
| 1922 | 1892 | |
| 1923 | 1893 | // create the window |
| 1924 | 1894 | snprintf(title, ARRAY_LENGTH(title), "Errorlog: %s [%s]", machine->gamedrv->description, machine->gamedrv->name); |
| 1925 | | info = debug_window_create(title, NULL); |
| 1895 | info = debug_window_create(machine, title, NULL); |
| 1926 | 1896 | if (!info || !debug_view_create(info, 0, DVT_LOG)) |
| 1927 | 1897 | return; |
| 1928 | 1898 | info->view->is_textbuf = TRUE; |
| r3563 | r3564 | |
| 1974 | 1944 | // first add all the CPUs' address spaces |
| 1975 | 1945 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 1976 | 1946 | { |
| 1977 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 1978 | | if (cpuinfo->valid) |
| 1947 | if (machine->cpu[cpunum] != NULL) |
| 1948 | { |
| 1949 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(machine->cpu[cpunum]); |
| 1979 | 1950 | for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++) |
| 1951 | { |
| 1980 | 1952 | if (cpuinfo->space[spacenum].databytes) |
| 1981 | 1953 | { |
| 1982 | 1954 | memorycombo_item *ci = malloc_or_die(sizeof(*ci)); |
| r3563 | r3564 | |
| 1984 | 1956 | ci->cpunum = cpunum; |
| 1985 | 1957 | ci->spacenum = spacenum; |
| 1986 | 1958 | ci->prefsize = MIN(cpuinfo->space[spacenum].databytes, 8); |
| 1987 | | snprintf(ci->name, ARRAY_LENGTH(ci->name), "CPU #%d \"%s\" (%s) %s memory", cpunum, machine->config->cpu[cpunum].tag, cpunum_name(cpunum), address_space_names[spacenum]); |
| 1959 | snprintf(ci->name, ARRAY_LENGTH(ci->name), "CPU #%d \"%s\" (%s) %s memory", cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum]), address_space_names[spacenum]); |
| 1988 | 1960 | *tail = ci; |
| 1989 | 1961 | tail = &ci->next; |
| 1990 | 1962 | } |
| 1963 | } |
| 1964 | } |
| 1991 | 1965 | } |
| 1992 | 1966 | |
| 1993 | 1967 | // then add all the memory regions |
| r3563 | r3564 | |
| 2072 | 2046 | |
| 2073 | 2047 | static void memory_create_window(running_machine *machine) |
| 2074 | 2048 | { |
| 2075 | | int curcpu = cpu_getactivecpu(), cursel = 0; |
| 2049 | int curcpu = cpunum_get_active(), cursel = 0; |
| 2076 | 2050 | memorycombo_item *ci, *selci = NULL; |
| 2077 | 2051 | debugwin_info *info; |
| 2078 | 2052 | MenuRef optionsmenu,popupmenu; |
| r3563 | r3564 | |
| 2083 | 2057 | ControlButtonContentInfo content; |
| 2084 | 2058 | |
| 2085 | 2059 | // create the window |
| 2086 | | info = debug_window_create("Memory", NULL); |
| 2060 | info = debug_window_create(machine, "Memory", NULL); |
| 2087 | 2061 | if (!info || !debug_view_create(info, 0, DVT_MEMORY)) |
| 2088 | 2062 | return; |
| 2089 | 2063 | |
| r3563 | r3564 | |
| 2581 | 2555 | // disasm_create_window |
| 2582 | 2556 | //============================================================ |
| 2583 | 2557 | |
| 2584 | | static void disasm_create_window(void) |
| 2558 | static void disasm_create_window(running_machine *machine) |
| 2585 | 2559 | { |
| 2586 | | int curcpu = cpu_getactivecpu(), cursel = 0; |
| 2560 | int curcpu = cpunum_get_active(), cursel = 0; |
| 2587 | 2561 | debugwin_info *info; |
| 2588 | 2562 | MenuRef optionsmenu, popupmenu; |
| 2589 | 2563 | UINT32 cpunum; |
| r3563 | r3564 | |
| 2594 | 2568 | ControlButtonContentInfo content; |
| 2595 | 2569 | |
| 2596 | 2570 | // create the window |
| 2597 | | info = debug_window_create("Disassembly", NULL); |
| 2571 | info = debug_window_create(machine, "Disassembly", NULL); |
| 2598 | 2572 | if (!info || !debug_view_create(info, 0, DVT_DISASSEMBLY)) |
| 2599 | 2573 | return; |
| 2600 | 2574 | |
| r3563 | r3564 | |
| 2677 | 2651 | // populate the combobox |
| 2678 | 2652 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 2679 | 2653 | { |
| 2680 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 2681 | | if (cpuinfo->valid) |
| 2654 | if (machine->cpu[cpunum] != NULL) |
| 2655 | { |
| 2656 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(machine->cpu[cpunum]); |
| 2682 | 2657 | if (cpuinfo->space[ADDRESS_SPACE_PROGRAM].databytes) |
| 2683 | 2658 | { |
| 2684 | 2659 | CFStringRef cfName; |
| 2685 | 2660 | char name[100]; |
| 2686 | 2661 | UInt16 item; |
| 2687 | 2662 | |
| 2688 | | snprintf(name, ARRAY_LENGTH(name), "CPU #%d \"%s\" (%s)", cpunum, Machine->config->cpu[cpunum].tag, cpunum_name(cpunum)); |
| 2663 | snprintf(name, ARRAY_LENGTH(name), "CPU #%d \"%s\" (%s)", cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum])); |
| 2689 | 2664 | |
| 2690 | 2665 | cfName = CFStringCreateWithCString( NULL, name, CFStringGetSystemEncoding() ); |
| 2691 | 2666 | AppendMenuItemTextWithCFString( popupmenu, cfName, 0, 0, &item ); |
| r3563 | r3564 | |
| 2694 | 2669 | if (cpunum == curcpu) |
| 2695 | 2670 | cursel = item; |
| 2696 | 2671 | } |
| 2672 | } |
| 2697 | 2673 | } |
| 2698 | 2674 | |
| 2699 | 2675 | SetControlData(info->otherwnd[0], kControlEntireControl, kControlPopupButtonOwnedMenuRefTag, sizeof(popupmenu),&popupmenu); |
| r3563 | r3564 | |
| 2884 | 2860 | UINT32 cpunum; |
| 2885 | 2861 | for (cpunum = 0; cpunum < MAX_CPU; cpunum++) |
| 2886 | 2862 | { |
| 2887 | | const debug_cpu_info *cpuinfo = debug_get_cpu_info(cpunum); |
| 2888 | | if (cpuinfo->valid) |
| 2863 | if (info->machine->cpu[cpunum] != NULL) |
| 2864 | { |
| 2865 | const cpu_debug_data *cpuinfo = cpu_get_debug_data(info->machine->cpu[cpunum]); |
| 2889 | 2866 | if (cpuinfo->space[ADDRESS_SPACE_PROGRAM].databytes) |
| 2867 | { |
| 2890 | 2868 | if (--sel == 0) |
| 2891 | 2869 | { |
| 2892 | 2870 | debug_view_begin_update(info->view[0].view); |
| r3563 | r3564 | |
| 2894 | 2872 | debug_view_end_update(info->view[0].view); |
| 2895 | 2873 | disasm_update_caption(info); |
| 2896 | 2874 | } |
| 2875 | } |
| 2876 | } |
| 2897 | 2877 | } |
| 2898 | 2878 | |
| 2899 | 2879 | // reset the focus |
| r3563 | r3564 | |
| 2932 | 2912 | { |
| 2933 | 2913 | active_address = debug_view_get_property_UINT32(info->view[0].view, DVP_DASM_ACTIVE_ADDRESS); |
| 2934 | 2914 | sprintf(command, "go %X", active_address); |
| 2935 | | debug_console_execute_command(Machine, command, 1); |
| 2915 | debug_console_execute_command(info->machine, command, 1); |
| 2936 | 2916 | } |
| 2937 | 2917 | return 1; |
| 2938 | 2918 | |
| r3563 | r3564 | |
| 2940 | 2920 | if (debug_view_get_property_UINT32(info->view[0].view, DVP_CURSOR_VISIBLE)) |
| 2941 | 2921 | { |
| 2942 | 2922 | UINT32 cpu_num = 0; |
| 2943 | | debug_cpu_info *cpuinfo ; |
| 2923 | cpu_debug_data *cpuinfo ; |
| 2944 | 2924 | debug_cpu_breakpoint *bp; |
| 2945 | 2925 | INT8 bp_exists = 0; |
| 2946 | 2926 | UINT32 bp_num = 0; |
| r3563 | r3564 | |
| 2950 | 2930 | |
| 2951 | 2931 | /* is there already a breakpoint there? */ |
| 2952 | 2932 | cpu_num = debug_view_get_property_UINT32(info->view[0].view, DVP_DASM_CPUNUM); |
| 2953 | | cpuinfo = (debug_cpu_info*)debug_get_cpu_info(cpu_num); |
| 2933 | cpuinfo = (cpu_debug_data*)cpu_get_debug_data(info->machine->cpu[cpu_num]); |
| 2954 | 2934 | |
| 2955 | 2935 | for (bp = cpuinfo->bplist; bp; bp = bp->next) |
| 2956 | 2936 | { |
| r3563 | r3564 | |
| 2966 | 2946 | sprintf(command, "bpset %X", BYTE2ADDR(active_address, cpuinfo, ADDRESS_SPACE_PROGRAM)); |
| 2967 | 2947 | else |
| 2968 | 2948 | sprintf(command, "bpclear %X", bp_num); |
| 2969 | | debug_console_execute_command(Machine, command, 1); |
| 2949 | debug_console_execute_command(info->machine, command, 1); |
| 2970 | 2950 | } |
| 2971 | 2951 | return 1; |
| 2972 | 2952 | } |
| r3563 | r3564 | |
| 3026 | 3006 | { |
| 3027 | 3007 | active_address = debug_view_get_property_UINT32(info->view[0].view, DVP_DASM_ACTIVE_ADDRESS); |
| 3028 | 3008 | sprintf(command, "go %X", active_address); |
| 3029 | | debug_console_execute_command(Machine, command, 1); |
| 3009 | debug_console_execute_command(info->machine, command, 1); |
| 3030 | 3010 | } |
| 3031 | 3011 | return 1; |
| 3032 | 3012 | |
| r3563 | r3564 | |
| 3034 | 3014 | if (debug_view_get_property_UINT32(info->view[0].view, DVP_CURSOR_VISIBLE)) |
| 3035 | 3015 | { |
| 3036 | 3016 | UINT32 cpu_num = 0; |
| 3037 | | debug_cpu_info *cpuinfo ; |
| 3017 | cpu_debug_data *cpuinfo ; |
| 3038 | 3018 | debug_cpu_breakpoint *bp; |
| 3039 | 3019 | INT8 bp_exists = 0; |
| 3040 | 3020 | UINT32 bp_num = 0; |
| r3563 | r3564 | |
| 3044 | 3024 | |
| 3045 | 3025 | /* is there already a breakpoint there? */ |
| 3046 | 3026 | cpu_num = debug_view_get_property_UINT32(info->view[0].view, DVP_DASM_CPUNUM); |
| 3047 | | cpuinfo = (debug_cpu_info*)debug_get_cpu_info(cpu_num); |
| 3027 | cpuinfo = (cpu_debug_data*)cpu_get_debug_data(info->machine->cpu[cpu_num]); |
| 3048 | 3028 | |
| 3049 | 3029 | for (bp = cpuinfo->bplist; bp; bp = bp->next) |
| 3050 | 3030 | { |
| r3563 | r3564 | |
| 3060 | 3040 | sprintf(command, "bpset %X", BYTE2ADDR(active_address, cpuinfo, ADDRESS_SPACE_PROGRAM)); |
| 3061 | 3041 | else |
| 3062 | 3042 | sprintf(command, "bpclear %X", bp_num); |
| 3063 | | debug_console_execute_command(Machine, command, 1); |
| 3043 | debug_console_execute_command(info->machine, command, 1); |
| 3064 | 3044 | } |
| 3065 | 3045 | return 1; |
| 3066 | 3046 | } |
| r3563 | r3564 | |
| 3069 | 3049 | { |
| 3070 | 3050 | if (debug_view_get_property_UINT32(info->view[0].view, DVP_CURSOR_VISIBLE)) |
| 3071 | 3051 | { |
| 3072 | | debug_cpu_single_step(1); |
| 3052 | debug_cpu_single_step(info->machine, 1); |
| 3073 | 3053 | return 1; |
| 3074 | 3054 | } |
| 3075 | 3055 | } |
| r3563 | r3564 | |
| 3094 | 3074 | cpunum = debug_view_get_property_UINT32(info->view[0].view, DVP_DASM_CPUNUM); |
| 3095 | 3075 | |
| 3096 | 3076 | // then update the caption |
| 3097 | | snprintf(title, ARRAY_LENGTH(title), "Disassembly: CPU #%d \"%s\" (%s)", cpunum, Machine->config->cpu[cpunum].tag, cpunum_name(cpunum)); |
| 3077 | snprintf(title, ARRAY_LENGTH(title), "Disassembly: CPU #%d \"%s\" (%s)", cpunum, info->machine->config->cpu[cpunum].tag, cpu_get_name(info->machine->cpu[cpunum])); |
| 3098 | 3078 | |
| 3099 | 3079 | cftitle = CFStringCreateWithCString( NULL, title, CFStringGetSystemEncoding() ); |
| 3100 | 3080 | |
| r3563 | r3564 | |
| 3125 | 3105 | ControlButtonContentInfo content; |
| 3126 | 3106 | |
| 3127 | 3107 | // create the window |
| 3128 | | info = debug_window_create("Debug", NULL); |
| 3108 | info = debug_window_create(machine, "Debug", NULL); |
| 3129 | 3109 | if (!info) |
| 3130 | 3110 | return; |
| 3131 | 3111 | main_console = info; |
| 3132 | | console_set_cpunum(Machine, 0); |
| 3112 | console_set_cpunum(machine, 0); |
| 3133 | 3113 | |
| 3134 | 3114 | // create the views |
| 3135 | 3115 | if (!debug_view_create(info, 0, DVT_DISASSEMBLY)) |
| r3563 | r3564 | |
| 3217 | 3197 | info->minwidth = 0; |
| 3218 | 3198 | info->maxwidth = 0; |
| 3219 | 3199 | for (cpunum = MAX_CPU - 1; (INT32)cpunum >= 0; cpunum--) |
| 3220 | | if (Machine->config->cpu[cpunum].type != CPU_DUMMY) |
| 3200 | if (machine->config->cpu[cpunum].type != CPU_DUMMY) |
| 3221 | 3201 | { |
| 3222 | 3202 | UINT32 regchars, dischars, conchars; |
| 3223 | 3203 | UINT32 minwidth, maxwidth; |
| r3563 | r3564 | |
| 3376 | 3356 | |
| 3377 | 3357 | // an empty string is a single step |
| 3378 | 3358 | if (string[0] == 0) |
| 3379 | | debug_cpu_single_step(1); |
| 3359 | debug_cpu_single_step(info->machine, 1); |
| 3380 | 3360 | |
| 3381 | 3361 | // otherwise, just process the command |
| 3382 | 3362 | else |
| 3383 | | debug_console_execute_command(Machine, string, 1); |
| 3363 | debug_console_execute_command(info->machine, string, 1); |
| 3384 | 3364 | |
| 3385 | 3365 | // clear the edit text box |
| 3386 | 3366 | SetControlData(info->editwnd, kControlEntireControl, kControlEditTextTextTag, 0, &buffer); |
| r3563 | r3564 | |
| 3404 | 3384 | debug_view_set_property_UINT32(main_console->view[1].view, DVP_REGS_CPUNUM, cpunum); |
| 3405 | 3385 | |
| 3406 | 3386 | // then update the caption |
| 3407 | | snprintf(title, ARRAY_LENGTH(title), "Debug: %s - CPU #%d \"%s\" (%s)", machine->gamedrv->name, cpu_getactivecpu(), machine->config->cpu[cpu_getactivecpu()].tag, activecpu_name()); |
| 3387 | snprintf(title, ARRAY_LENGTH(title), "Debug: %s - CPU #%d \"%s\" (%s)", machine->gamedrv->name, cpunum, machine->config->cpu[cpunum].tag, cpu_get_name(machine->cpu[cpunum])); |
| 3408 | 3388 | |
| 3409 | 3389 | cftitle = CFStringCreateWithCString( NULL, title, CFStringGetSystemEncoding() ); |
| 3410 | 3390 | |
| r3563 | r3564 | |
| 3482 | 3462 | switch( cmd.commandID ) |
| 3483 | 3463 | { |
| 3484 | 3464 | case ID_NEW_MEMORY_WND: |
| 3485 | | memory_create_window(Machine); |
| 3465 | memory_create_window(info->machine); |
| 3486 | 3466 | return 1; |
| 3487 | 3467 | |
| 3488 | 3468 | case ID_NEW_DISASM_WND: |
| 3489 | | disasm_create_window(); |
| 3469 | disasm_create_window(info->machine); |
| 3490 | 3470 | return 1; |
| 3491 | 3471 | |
| 3492 | 3472 | case ID_NEW_LOG_WND: |
| 3493 | | log_create_window(Machine); |
| 3473 | log_create_window(info->machine); |
| 3494 | 3474 | return 1; |
| 3495 | 3475 | |
| 3496 | 3476 | case ID_RUN_AND_HIDE: |
| 3497 | 3477 | smart_show_all(FALSE); |
| 3498 | 3478 | case ID_RUN: |
| 3499 | | debug_cpu_go(~0); |
| 3479 | debug_cpu_go(info->machine, ~0); |
| 3500 | 3480 | return 1; |
| 3501 | 3481 | |
| 3502 | 3482 | case ID_NEXT_CPU: |
| 3503 | | debug_cpu_next_cpu(); |
| 3483 | debug_cpu_next_cpu(info->machine); |
| 3504 | 3484 | return 1; |
| 3505 | 3485 | |
| 3506 | 3486 | case ID_RUN_VBLANK: |
| 3507 | | debug_cpu_go_vblank(); |
| 3487 | debug_cpu_go_vblank(info->machine); |
| 3508 | 3488 | return 1; |
| 3509 | 3489 | |
| 3510 | 3490 | case ID_RUN_IRQ: |
| 3511 | | debug_cpu_go_interrupt(-1); |
| 3491 | debug_cpu_go_interrupt(info->machine, -1); |
| 3512 | 3492 | return 1; |
| 3513 | 3493 | |
| 3514 | 3494 | case ID_STEP: |
| 3515 | | debug_cpu_single_step(1); |
| 3495 | debug_cpu_single_step(info->machine, 1); |
| 3516 | 3496 | return 1; |
| 3517 | 3497 | |
| 3518 | 3498 | case ID_STEP_OVER: |
| 3519 | | debug_cpu_single_step_over(1); |
| 3499 | debug_cpu_single_step_over(info->machine, 1); |
| 3520 | 3500 | return 1; |
| 3521 | 3501 | |
| 3522 | 3502 | case ID_STEP_OUT: |
| 3523 | | debug_cpu_single_step_out(); |
| 3503 | debug_cpu_single_step_out(info->machine); |
| 3524 | 3504 | return 1; |
| 3525 | 3505 | |
| 3526 | 3506 | case ID_HARD_RESET: |
| 3527 | | mame_schedule_hard_reset(Machine); |
| 3507 | mame_schedule_hard_reset(info->machine); |
| 3528 | 3508 | return 1; |
| 3529 | 3509 | |
| 3530 | 3510 | case ID_SOFT_RESET: |
| 3531 | | mame_schedule_soft_reset(Machine); |
| 3532 | | debug_cpu_go(~0); |
| 3511 | mame_schedule_soft_reset(info->machine); |
| 3512 | debug_cpu_go(info->machine, ~0); |
| 3533 | 3513 | return 1; |
| 3534 | 3514 | |
| 3535 | 3515 | case ID_EXIT: |
| 3536 | | mame_schedule_exit(Machine); |
| 3516 | mame_schedule_exit(info->machine); |
| 3537 | 3517 | return 1; |
| 3538 | 3518 | } |
| 3539 | 3519 | |
| r3563 | r3564 | |
| 3552 | 3532 | int ignoreme; |
| 3553 | 3533 | |
| 3554 | 3534 | /* ignore any keys that are received while the debug key is down */ |
| 3555 | | ignoreme = ui_input_pressed(Machine, IPT_UI_DEBUG_BREAK); |
| 3535 | ignoreme = ui_input_pressed(info->machine, IPT_UI_DEBUG_BREAK); |
| 3556 | 3536 | if (ignoreme) |
| 3557 | 3537 | return 1; |
| 3558 | 3538 | |
| r3563 | r3564 | |
| 3562 | 3542 | { |
| 3563 | 3543 | case KEY_F3: |
| 3564 | 3544 | if ( event.modifiers & shiftKey ) |
| 3565 | | mame_schedule_hard_reset(Machine); |
| 3545 | mame_schedule_hard_reset(info->machine); |
| 3566 | 3546 | else |
| 3567 | 3547 | { |
| 3568 | | mame_schedule_soft_reset(Machine); |
| 3569 | | debug_cpu_go(~0); |
| 3548 | mame_schedule_soft_reset(info->machine); |
| 3549 | debug_cpu_go(info->machine,~0); |
| 3570 | 3550 | } |
| 3571 | 3551 | return 1; |
| 3572 | 3552 | |
| 3573 | 3553 | case KEY_F4: |
| 3574 | 3554 | if ( event.modifiers & optionKey ) |
| 3575 | | mame_schedule_exit(Machine); |
| 3555 | mame_schedule_exit(info->machine); |
| 3576 | 3556 | return 1; |
| 3577 | 3557 | |
| 3578 | 3558 | case KEY_F5: |
| 3579 | | debug_cpu_go(~0); |
| 3559 | debug_cpu_go(info->machine, ~0); |
| 3580 | 3560 | return 1; |
| 3581 | 3561 | |
| 3582 | 3562 | case KEY_F6: |
| 3583 | | debug_cpu_next_cpu(); |
| 3563 | debug_cpu_next_cpu(info->machine); |
| 3584 | 3564 | return 1; |
| 3585 | 3565 | |
| 3586 | 3566 | case KEY_F7: |
| 3587 | | debug_cpu_go_interrupt(-1); |
| 3567 | debug_cpu_go_interrupt(info->machine, -1); |
| 3588 | 3568 | return 1; |
| 3589 | 3569 | |
| 3590 | 3570 | case KEY_F8: |
| 3591 | | debug_cpu_go_vblank(); |
| 3571 | debug_cpu_go_vblank(info->machine); |
| 3592 | 3572 | return 1; |
| 3593 | 3573 | |
| 3594 | 3574 | case KEY_F10: |
| 3595 | | debug_cpu_single_step_over(1); |
| 3575 | debug_cpu_single_step_over(info->machine, 1); |
| 3596 | 3576 | return 1; |
| 3597 | 3577 | |
| 3598 | 3578 | case KEY_F11: |
| 3599 | 3579 | if ( event.modifiers & shiftKey ) |
| 3600 | | debug_cpu_single_step_out(); |
| 3580 | debug_cpu_single_step_out(info->machine); |
| 3601 | 3581 | else |
| 3602 | | debug_cpu_single_step(1); |
| 3582 | debug_cpu_single_step(info->machine, 1); |
| 3603 | 3583 | return 1; |
| 3604 | 3584 | |
| 3605 | 3585 | case KEY_F12: |
| 3606 | 3586 | smart_show_all(FALSE); |
| 3607 | | debug_cpu_go(~0); |
| 3587 | debug_cpu_go(info->machine, ~0); |
| 3608 | 3588 | return 1; |
| 3609 | 3589 | } |
| 3610 | 3590 | |
| r3563 | r3564 | |
| 3614 | 3594 | { |
| 3615 | 3595 | case 'm': |
| 3616 | 3596 | case 'M': |
| 3617 | | memory_create_window(Machine); |
| 3597 | memory_create_window(info->machine); |
| 3618 | 3598 | return 1; |
| 3619 | 3599 | |
| 3620 | 3600 | case 'd': |
| 3621 | 3601 | case 'D': |
| 3622 | | disasm_create_window(); |
| 3602 | disasm_create_window(info->machine); |
| 3623 | 3603 | return 1; |
| 3624 | 3604 | |
| 3625 | 3605 | case 'l': |
| 3626 | 3606 | case 'L': |
| 3627 | | log_create_window(Machine); |
| 3607 | log_create_window(info->machine); |
| 3628 | 3608 | return 1; |
| 3629 | 3609 | } |
| 3630 | 3610 | } |
src/osd/sdl/debug-intf.c
| r3563 | r3564 | |
| 15 | 15 | #include <gdk/gdkkeysyms.h> |
| 16 | 16 | #include <gtk/gtk.h> |
| 17 | 17 | |
| 18 | #include "driver.h" |
| 18 | 19 | #include "debug-cb.h" |
| 19 | 20 | #include "debug-intf.h" |
| 20 | 21 | #include "debug-sup.h" |
| r3563 | r3564 | |
| 29 | 30 | g_object_set_data (G_OBJECT (component), name, widget) |
| 30 | 31 | |
| 31 | 32 | GtkWidget* |
| 32 | | create_debugmain (void) |
| 33 | create_debugmain (running_machine *machine) |
| 33 | 34 | { |
| 34 | 35 | GtkWidget *debugmain; |
| 35 | 36 | GtkWidget *vbox1; |
| r3563 | r3564 | |
| 298 | 299 | |
| 299 | 300 | g_signal_connect ((gpointer) new_mem, "activate", |
| 300 | 301 | G_CALLBACK (on_new_mem_activate), |
| 301 | | NULL); |
| 302 | machine); |
| 302 | 303 | g_signal_connect ((gpointer) new_disasm, "activate", |
| 303 | 304 | G_CALLBACK (on_new_disasm_activate), |
| 304 | | NULL); |
| 305 | machine); |
| 305 | 306 | g_signal_connect ((gpointer) new_errorlog, "activate", |
| 306 | 307 | G_CALLBACK (on_new_errorlog_activate), |
| 307 | | NULL); |
| 308 | machine); |
| 308 | 309 | g_signal_connect ((gpointer) run, "activate", |
| 309 | 310 | G_CALLBACK (on_run_activate), |
| 310 | | NULL); |
| 311 | machine); |
| 311 | 312 | g_signal_connect ((gpointer) run_h, "activate", |
| 312 | 313 | G_CALLBACK (on_run_h_activate), |
| 313 | | NULL); |
| 314 | machine); |
| 314 | 315 | g_signal_connect ((gpointer) run_cpu, "activate", |
| 315 | 316 | G_CALLBACK (on_run_cpu_activate), |
| 316 | | NULL); |
| 317 | machine); |
| 317 | 318 | g_signal_connect ((gpointer) run_irq, "activate", |
| 318 | 319 | G_CALLBACK (on_run_irq_activate), |
| 319 | | NULL); |
| 320 | machine); |
| 320 | 321 | g_signal_connect ((gpointer) run_vbl, "activate", |
| 321 | 322 | G_CALLBACK (on_run_vbl_activate), |
| 322 | | NULL); |
| 323 | machine); |
| 323 | 324 | g_signal_connect ((gpointer) step_into, "activate", |
| 324 | 325 | G_CALLBACK (on_step_into_activate), |
| 325 | | NULL); |
| 326 | machine); |
| 326 | 327 | g_signal_connect ((gpointer) step_over, "activate", |
| 327 | 328 | G_CALLBACK (on_step_over_activate), |
| 328 | | NULL); |
| 329 | machine); |
| 329 | 330 | g_signal_connect ((gpointer) step_out, "activate", |
| 330 | 331 | G_CALLBACK (on_step_out_activate), |
| 331 | | NULL); |
| 332 | machine); |
| 332 | 333 | g_signal_connect ((gpointer) soft_reset, "activate", |
| 333 | 334 | G_CALLBACK (on_soft_reset_activate), |
| 334 | | NULL); |
| 335 | machine); |
| 335 | 336 | g_signal_connect ((gpointer) hard_reset, "activate", |
| 336 | 337 | G_CALLBACK (on_hard_reset_activate), |
| 337 | | NULL); |
| 338 | machine); |
| 338 | 339 | g_signal_connect ((gpointer) exit, "activate", |
| 339 | 340 | G_CALLBACK (on_exit_activate), |
| 340 | | NULL); |
| 341 | machine); |
| 341 | 342 | |
| 342 | 343 | /* Store pointers to all widgets, for use by lookup_widget(). */ |
| 343 | 344 | GLADE_HOOKUP_OBJECT_NO_REF (debugmain, debugmain, "debugmain"); |
| r3563 | r3564 | |
| 381 | 382 | } |
| 382 | 383 | |
| 383 | 384 | GtkWidget* |
| 384 | | create_memorywin (void) |
| 385 | create_memorywin (running_machine *machine) |
| 385 | 386 | { |
| 386 | 387 | GtkWidget *memorywin; |
| 387 | 388 | GtkWidget *vbox3; |
| r3563 | r3564 | |
| 673 | 674 | |
| 674 | 675 | g_signal_connect ((gpointer) new_mem, "activate", |
| 675 | 676 | G_CALLBACK (on_new_mem_activate), |
| 676 | | NULL); |
| 677 | machine); |
| 677 | 678 | g_signal_connect ((gpointer) new_disasm, "activate", |
| 678 | 679 | G_CALLBACK (on_new_disasm_activate), |
| 679 | | NULL); |
| 680 | machine); |
| 680 | 681 | g_signal_connect ((gpointer) new_errorlog, "activate", |
| 681 | 682 | G_CALLBACK (on_new_errorlog_activate), |
| 682 | | NULL); |
| 683 | machine); |
| 683 | 684 | g_signal_connect ((gpointer) run, "activate", |
| 684 | 685 | G_CALLBACK (on_run_activate), |
| 685 | | NULL); |
| 686 | machine); |
| 686 | 687 | g_signal_connect ((gpointer) run_h, "activate", |
| 687 | 688 | G_CALLBACK (on_run_h_activate), |
| 688 | | NULL); |
| 689 | machine); |
| 689 | 690 | g_signal_connect ((gpointer) run_cpu, "activate", |
| 690 | 691 | G_CALLBACK (on_run_cpu_activate), |
| 691 | | NULL); |
| 692 | machine); |
| 692 | 693 | g_signal_connect ((gpointer) run_irq, "activate", |
| 693 | 694 | G_CALLBACK (on_run_irq_activate), |
| 694 | | NULL); |
| 695 | machine); |
| 695 | 696 | g_signal_connect ((gpointer) run_vbl, "activate", |
| 696 | 697 | G_CALLBACK (on_run_vbl_activate), |
| 697 | | NULL); |
| 698 | machine); |
| 698 | 699 | g_signal_connect ((gpointer) step_into, "activate", |
| 699 | 700 | G_CALLBACK (on_step_into_activate), |
| 700 | | NULL); |
| 701 | machine); |
| 701 | 702 | g_signal_connect ((gpointer) step_over, "activate", |
| 702 | 703 | G_CALLBACK (on_step_over_activate), |
| 703 | | NULL); |
| 704 | machine); |
| 704 | 705 | g_signal_connect ((gpointer) step_out, "activate", |
| 705 | 706 | G_CALLBACK (on_step_out_activate), |
| 706 | | NULL); |
| 707 | machine); |
| 707 | 708 | g_signal_connect ((gpointer) soft_reset, "activate", |
| 708 | 709 | G_CALLBACK (on_soft_reset_activate), |
| 709 | | NULL); |
| 710 | machine); |
| 710 | 711 | g_signal_connect ((gpointer) hard_reset, "activate", |
| 711 | 712 | G_CALLBACK (on_hard_reset_activate), |
| 712 | | NULL); |
| 713 | machine); |
| 713 | 714 | g_signal_connect ((gpointer) exit, "activate", |
| 714 | 715 | G_CALLBACK (on_exit_activate), |
| 715 | | NULL); |
| 716 | machine); |
| 716 | 717 | |
| 717 | 718 | /* Store pointers to all widgets, for use by lookup_widget(). */ |
| 718 | 719 | GLADE_HOOKUP_OBJECT_NO_REF (memorywin, memorywin, "memorywin"); |
| r3563 | r3564 | |
| 758 | 759 | } |
| 759 | 760 | |
| 760 | 761 | GtkWidget* |
| 761 | | create_disasmwin (void) |
| 762 | create_disasmwin (running_machine *machine) |
| 762 | 763 | { |
| 763 | 764 | GtkWidget *disasmwin; |
| 764 | 765 | GtkWidget *vbox4; |
| r3563 | r3564 | |
| 1009 | 1010 | |
| 1010 | 1011 | g_signal_connect ((gpointer) menuitem6, "activate", |
| 1011 | 1012 | G_CALLBACK (on_new_mem_activate), |
| 1012 | | NULL); |
| 1013 | machine); |
| 1013 | 1014 | g_signal_connect ((gpointer) menuitem7, "activate", |
| 1014 | 1015 | G_CALLBACK (on_new_disasm_activate), |
| 1015 | | NULL); |
| 1016 | machine); |
| 1016 | 1017 | g_signal_connect ((gpointer) menuitem8, "activate", |
| 1017 | 1018 | G_CALLBACK (on_new_errorlog_activate), |
| 1018 | | NULL); |
| 1019 | machine); |
| 1019 | 1020 | g_signal_connect ((gpointer) menuitem9, "activate", |
| 1020 | 1021 | G_CALLBACK (on_run_activate), |
| 1021 | | NULL); |
| 1022 | machine); |
| 1022 | 1023 | g_signal_connect ((gpointer) menuitem10, "activate", |
| 1023 | 1024 | G_CALLBACK (on_run_h_activate), |
| 1024 | | NULL); |
| 1025 | machine); |
| 1025 | 1026 | g_signal_connect ((gpointer) menuitem11, "activate", |
| 1026 | 1027 | G_CALLBACK (on_run_cpu_activate), |
| 1027 | | NULL); |
| 1028 | machine); |
| 1028 | 1029 | g_signal_connect ((gpointer) menuitem12, "activate", |
| 1029 | 1030 | G_CALLBACK (on_run_irq_activate), |
| 1030 | | NULL); |
| 1031 | machine); |
| 1031 | 1032 | g_signal_connect ((gpointer) menuitem13, "activate", |
| 1032 | 1033 | G_CALLBACK (on_run_vbl_activate), |
| 1033 | | NULL); |
| 1034 | machine); |
| 1034 | 1035 | g_signal_connect ((gpointer) menuitem14, "activate", |
| 1035 | 1036 | G_CALLBACK (on_step_into_activate), |
| 1036 | | NULL); |
| 1037 | machine); |
| 1037 | 1038 | g_signal_connect ((gpointer) menuitem15, "activate", |
| 1038 | 1039 | G_CALLBACK (on_step_over_activate), |
| 1039 | | NULL); |
| 1040 | machine); |
| 1040 | 1041 | g_signal_connect ((gpointer) menuitem16, "activate", |
| 1041 | 1042 | G_CALLBACK (on_step_out_activate), |
| 1042 | | NULL); |
| 1043 | machine); |
| 1043 | 1044 | g_signal_connect ((gpointer) menuitem17, "activate", |
| 1044 | 1045 | G_CALLBACK (on_soft_reset_activate), |
| 1045 | | NULL); |
| 1046 | machine); |
| 1046 | 1047 | g_signal_connect ((gpointer) menuitem18, "activate", |
| 1047 | 1048 | G_CALLBACK (on_hard_reset_activate), |
| 1048 | | NULL); |
| 1049 | machine); |
| 1049 | 1050 | g_signal_connect ((gpointer) menuitem19, "activate", |
| 1050 | 1051 | G_CALLBACK (on_exit_activate), |
| 1051 | | NULL); |
| 1052 | machine); |
| 1052 | 1053 | |
| 1053 | 1054 | /* Store pointers to all widgets, for use by lookup_widget(). */ |
| 1054 | 1055 | GLADE_HOOKUP_OBJECT_NO_REF (disasmwin, disasmwin, "disasmwin"); |
| r3563 | r3564 | |
| 1089 | 1090 | } |
| 1090 | 1091 | |
| 1091 | 1092 | GtkWidget* |
| 1092 | | create_logwin (void) |
| 1093 | create_logwin (running_machine *machine) |
| 1093 | 1094 | { |
| 1094 | 1095 | GtkWidget *logwin; |
| 1095 | 1096 | GtkWidget *vbox5; |
| r3563 | r3564 | |
| 1277 | 1278 | |
| 1278 | 1279 | g_signal_connect ((gpointer) menuitem27, "activate", |
| 1279 | 1280 | G_CALLBACK (on_new_mem_activate), |
| 1280 | | NULL); |
| 1281 | machine); |
| 1281 | 1282 | g_signal_connect ((gpointer) menuitem28, "activate", |
| 1282 | 1283 | G_CALLBACK (on_new_disasm_activate), |
| 1283 | | NULL); |
| 1284 | machine); |
| 1284 | 1285 | g_signal_connect ((gpointer) menuitem29, "activate", |
| 1285 | 1286 | G_CALLBACK (on_new_errorlog_activate), |
| 1286 | | NULL); |
| 1287 | machine); |
| 1287 | 1288 | g_signal_connect ((gpointer) menuitem30, "activate", |
| 1288 | 1289 | G_CALLBACK (on_run_activate), |
| 1289 | | NULL); |
| 1290 | machine); |
| 1290 | 1291 | g_signal_connect ((gpointer) menuitem31, "activate", |
| 1291 | 1292 | G_CALLBACK (on_run_h_activate), |
| 1292 | | NULL); |
| 1293 | machine); |
| 1293 | 1294 | g_signal_connect ((gpointer) menuitem32, "activate", |
| 1294 | 1295 | G_CALLBACK (on_run_cpu_activate), |
| 1295 | | NULL); |
| 1296 | machine); |
| 1296 | 1297 | g_signal_connect ((gpointer) menuitem33, "activate", |
| 1297 | 1298 | G_CALLBACK (on_run_irq_activate), |
| 1298 | | NULL); |
| 1299 | machine); |
| 1299 | 1300 | g_signal_connect ((gpointer) menuitem34, "activate", |
| 1300 | 1301 | G_CALLBACK (on_run_vbl_activate), |
| 1301 | | NULL); |
| 1302 | machine); |
| 1302 | 1303 | g_signal_connect ((gpointer) menuitem35, "activate", |
| 1303 | 1304 | G_CALLBACK (on_step_into_activate), |
| 1304 | | NULL); |
| 1305 | machine); |
| 1305 | 1306 | g_signal_connect ((gpointer) menuitem36, "activate", |
| 1306 | 1307 | G_CALLBACK (on_step_over_activate), |
| 1307 | | NULL); |
| 1308 | machine); |
| 1308 | 1309 | g_signal_connect ((gpointer) menuitem37, "activate", |
| 1309 | 1310 | G_CALLBACK (on_step_out_activate), |
| 1310 | | NULL); |
| 1311 | machine); |
| 1311 | 1312 | g_signal_connect ((gpointer) menuitem38, "activate", |
| 1312 | 1313 | G_CALLBACK (on_soft_reset_activate), |
| 1313 | | NULL); |
| 1314 | machine); |
| 1314 | 1315 | g_signal_connect ((gpointer) menuitem39, "activate", |
| 1315 | 1316 | G_CALLBACK (on_hard_reset_activate), |
| 1316 | | NULL); |
| 1317 | machine); |
| 1317 | 1318 | g_signal_connect ((gpointer) menuitem40, "activate", |
| 1318 | 1319 | G_CALLBACK (on_exit_activate), |
| 1319 | | NULL); |
| 1320 | machine); |
| 1320 | 1321 | |
| 1321 | 1322 | /* Store pointers to all widgets, for use by lookup_widget(). */ |
| 1322 | 1323 | GLADE_HOOKUP_OBJECT_NO_REF (logwin, logwin, "logwin"); |