![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debugui.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src / debug|
Return to debugui.c CVS log | Up to [Previous NeXT emulator] / previous / src / debug |
1.1 ! root 1: /* ! 2: Hatari - debugui.c ! 3: ! 4: This file is distributed under the GNU Public License, version 2 or at ! 5: your option any later version. Read the file gpl.txt for details. ! 6: ! 7: debugui.c - this is the code for the mini-debugger. When the pause button is ! 8: pressed, the emulator is (hopefully) halted and this little CLI can be used ! 9: (in the terminal box) for debugging tasks like memory and register dumps. ! 10: */ ! 11: const char DebugUI_fileid[] = "Hatari debugui.c : " __DATE__ " " __TIME__; ! 12: ! 13: #include <ctype.h> ! 14: #include <stdio.h> ! 15: #include <unistd.h> ! 16: ! 17: #include "config.h" ! 18: ! 19: #if HAVE_LIBREADLINE ! 20: #include <readline/readline.h> ! 21: #include <readline/history.h> ! 22: #endif ! 23: ! 24: #include "main.h" ! 25: #include "change.h" ! 26: #include "configuration.h" ! 27: #include "file.h" ! 28: #include "log.h" ! 29: #include "m68000.h" ! 30: #include "memorySnapShot.h" ! 31: #include "options.h" ! 32: #include "screen.h" ! 33: #include "statusbar.h" ! 34: #include "str.h" ! 35: ! 36: #include "debug_priv.h" ! 37: #include "breakcond.h" ! 38: #include "debugcpu.h" ! 39: #include "debugInfo.h" ! 40: #include "debugui.h" ! 41: #include "evaluate.h" ! 42: #include "symbols.h" ! 43: ! 44: int bExceptionDebugging; ! 45: ! 46: FILE *debugOutput; ! 47: ! 48: static dbgcommand_t *debugCommand; ! 49: static int debugCommands; ! 50: ! 51: /* stores last 'e' command result as hex, used for TAB-completion */ ! 52: static char lastResult[10]; ! 53: ! 54: static const char *parseFileName; ! 55: static bool DebugUI_ParseFile(const char *path); ! 56: ! 57: ! 58: /** ! 59: * Save/Restore snapshot of debugging session variables ! 60: */ ! 61: void DebugUI_MemorySnapShot_Capture(const char *path, bool bSave) ! 62: { ! 63: char *filename; ! 64: ! 65: filename = malloc(strlen(path) + strlen(".debug") + 1); ! 66: assert(filename); ! 67: strcpy(filename, path); ! 68: strcat(filename, ".debug"); ! 69: ! 70: if (bSave) ! 71: { ! 72: /* save breakpoints as debugger input file */ ! 73: BreakCond_Save(filename); ! 74: } ! 75: else ! 76: { ! 77: /* remove current CPU and DSP breakpoints */ ! 78: BreakCond_Command("all", false); ! 79: BreakCond_Command("all", true); ! 80: ! 81: if (File_Exists(filename)) ! 82: { ! 83: /* and parse back the saved breakpoints */ ! 84: DebugUI_ParseFile(filename); ! 85: } ! 86: } ! 87: free(filename); ! 88: } ! 89: ! 90: ! 91: /** ! 92: * Close a log file if open, and set it to default stream. ! 93: */ ! 94: static void DebugUI_SetLogDefault(void) ! 95: { ! 96: if (debugOutput != stderr) ! 97: { ! 98: if (debugOutput) ! 99: { ! 100: File_Close(debugOutput); ! 101: fprintf(stderr, "Debug log closed.\n"); ! 102: } ! 103: debugOutput = stderr; ! 104: } ! 105: } ! 106: ! 107: ! 108: /** ! 109: * Open (or close) given log file. ! 110: */ ! 111: static int DebugUI_SetLogFile(int nArgc, char *psArgs[]) ! 112: { ! 113: File_Close(debugOutput); ! 114: debugOutput = NULL; ! 115: ! 116: if (nArgc > 1) ! 117: debugOutput = File_Open(psArgs[1], "w"); ! 118: ! 119: if (debugOutput) ! 120: fprintf(stderr, "Debug log '%s' opened.\n", psArgs[1]); ! 121: else ! 122: debugOutput = stderr; ! 123: ! 124: return DEBUGGER_CMDDONE; ! 125: } ! 126: ! 127: ! 128: /** ! 129: * Helper to print given value in all supported number bases ! 130: */ ! 131: static void DebugUI_PrintValue(Uint32 value) ! 132: { ! 133: bool one, ones; ! 134: int bit; ! 135: ! 136: fputs("= %", stderr); ! 137: ones = false; ! 138: for (bit = 31; bit >= 0; bit--) ! 139: { ! 140: one = value & (1<<bit); ! 141: if (one || ones) ! 142: { ! 143: fputc(one ? '1':'0', stderr); ! 144: ones = true; ! 145: } ! 146: } ! 147: if (!ones) ! 148: fputc('0', stderr); ! 149: if (value & 0x80000000) ! 150: fprintf(stderr, " (bin), #%u/%d (dec), $%x (hex)\n", value, (int)value, value); ! 151: else ! 152: fprintf(stderr, " (bin), #%u (dec), $%x (hex)\n", value, value); ! 153: ! 154: sprintf(lastResult, "%x", value); ! 155: } ! 156: ! 157: ! 158: /** ! 159: * Commmand: Evaluate an expression with CPU reg and symbol parsing. ! 160: */ ! 161: static int DebugUI_Evaluate(int nArgc, char *psArgs[]) ! 162: { ! 163: const char *errstr, *expression = (const char *)psArgs[1]; ! 164: Uint32 result; ! 165: int offset; ! 166: ! 167: if (nArgc < 2) ! 168: { ! 169: DebugUI_PrintCmdHelp(psArgs[0]); ! 170: return DEBUGGER_CMDDONE; ! 171: } ! 172: ! 173: errstr = Eval_Expression(expression, &result, &offset, false); ! 174: if (errstr) ! 175: fprintf(stderr, "ERROR in the expression:\n'%s'\n%*c-%s\n", ! 176: expression, offset+3, '^', errstr); ! 177: else ! 178: DebugUI_PrintValue(result); ! 179: return DEBUGGER_CMDDONE; ! 180: } ! 181: ! 182: ! 183: /** ! 184: * Check whether given string is a two letter command starting with 'd' ! 185: * or a long command starting with "dsp". String should be trimmed. ! 186: * Return true if given string is command for DSP, false otherwise. ! 187: */ ! 188: static bool DebugUI_IsForDsp(const char *cmd) ! 189: { ! 190: return ((cmd[0] == 'd' && cmd[1] && !cmd[2]) ! 191: || strncmp(cmd, "dsp", 3) == 0); ! 192: } ! 193: ! 194: /** ! 195: * Evaluate everything include within "" and replace them with the result. ! 196: * String given as an argument needs to be allocated, it may be freed and ! 197: * re-allocated if it needs to be expanded. Caller needs to free the returned ! 198: * string if it's not NULL. ! 199: * ! 200: * Return string with expressions expanded or NULL for an error. ! 201: */ ! 202: static char *DebugUI_EvaluateExpressions(char *input) ! 203: { ! 204: int offset, count, diff, inputlen; ! 205: char *end, *start; ! 206: const char *errstr; ! 207: char valuestr[12]; ! 208: Uint32 value; ! 209: bool fordsp; ! 210: ! 211: /* input is split later on, need to save len here */ ! 212: fordsp = DebugUI_IsForDsp(input); ! 213: inputlen = strlen(input); ! 214: start = input; ! 215: ! 216: while ((start = strchr(start, '"'))) ! 217: { ! 218: end = strchr(start+1, '"'); ! 219: if (!end) ! 220: { ! 221: fprintf(stderr, "ERROR: matching '\"' missing from '%s'!\n", start); ! 222: free(input); ! 223: return NULL; ! 224: } ! 225: ! 226: if (end == start+1) ! 227: { ! 228: /* empty expression */ ! 229: memmove(start, start+2, strlen(start+2)+1); ! 230: continue; ! 231: } ! 232: ! 233: *end = '\0'; ! 234: errstr = Eval_Expression(start+1, &value, &offset, fordsp); ! 235: if (errstr) { ! 236: *end = '"'; ! 237: fprintf(stderr, "Expression ERROR:\n'%s'\n%*c-%s\n", ! 238: input, (int)(start-input)+offset+3, '^', errstr); ! 239: free(input); ! 240: return NULL; ! 241: } ! 242: end++; ! 243: ! 244: count = sprintf(valuestr, "$%x", value); ! 245: fprintf(stderr, "- \"%s\" -> %s\n", start+1, valuestr); ! 246: ! 247: diff = end-start; ! 248: if (count < diff) ! 249: { ! 250: memcpy(start, valuestr, count); ! 251: start += count; ! 252: memmove(start, end, strlen(end) + 1); ! 253: } else { ! 254: /* value won't fit to expression, expand string */ ! 255: char *tmp; ! 256: inputlen += count-diff+1; ! 257: tmp = malloc(inputlen+1); ! 258: if (!tmp) ! 259: { ! 260: perror("ERROR: Input string alloc failed\n"); ! 261: free(input); ! 262: return NULL; ! 263: } ! 264: ! 265: memcpy(tmp, input, start-input); ! 266: start = tmp+(start-input); ! 267: memcpy(start, valuestr, count); ! 268: start += count; ! 269: memcpy(start, end, strlen(end) + 1); ! 270: ! 271: free(input); ! 272: input = tmp; ! 273: } ! 274: } ! 275: /* no (more) expressions to evaluate */ ! 276: return input; ! 277: } ! 278: ! 279: ! 280: /** ! 281: * Command: Store and restore emulation state ! 282: */ ! 283: static int DebugUI_DoMemorySnap(int argc, char *argv[]) ! 284: { ! 285: const char *file; ! 286: ! 287: if (argc > 1) ! 288: file = argv[1]; ! 289: else ! 290: file = ConfigureParams.Memory.szMemoryCaptureFileName; ! 291: ! 292: if (strcmp(argv[0], "stateload") == 0) ! 293: MemorySnapShot_Restore(file, true); ! 294: else ! 295: MemorySnapShot_Capture(file, true); ! 296: ! 297: return DEBUGGER_CMDDONE; ! 298: } ! 299: ! 300: ! 301: /** ! 302: * Command: Set command line and debugger options ! 303: */ ! 304: static int DebugUI_SetOptions(int argc, char *argv[]) ! 305: { ! 306: CNF_PARAMS current; ! 307: static const struct { ! 308: const char name[4]; ! 309: int base; ! 310: } bases[] = { ! 311: { "bin", 2 }, ! 312: { "dec", 10 }, ! 313: { "hex", 16 } ! 314: }; ! 315: const char *arg; ! 316: int i; ! 317: ! 318: if (argc < 2) ! 319: { ! 320: DebugUI_PrintCmdHelp(argv[0]); ! 321: return DEBUGGER_CMDDONE; ! 322: } ! 323: arg = argv[1]; ! 324: ! 325: for (i = 0; i < ARRAYSIZE(bases); i++) ! 326: { ! 327: if (strcasecmp(bases[i].name, arg) == 0) ! 328: { ! 329: if (ConfigureParams.Debugger.nNumberBase != bases[i].base) ! 330: { ! 331: fprintf(stderr, "Switched default number base from %d to %d-based (%s) values.\n", ! 332: ConfigureParams.Debugger.nNumberBase, ! 333: bases[i].base, bases[i].name); ! 334: ConfigureParams.Debugger.nNumberBase = bases[i].base; ! 335: } else { ! 336: fprintf(stderr, "Already in '%s' mode.\n", bases[i].name); ! 337: } ! 338: return DEBUGGER_CMDDONE; ! 339: } ! 340: } ! 341: ! 342: /* get configuration changes */ ! 343: current = ConfigureParams; ! 344: ! 345: /* Parse and apply options */ ! 346: if (Opt_ParseParameters(argc, (const char**)argv)) ! 347: { ! 348: ConfigureParams.Screen.bFullScreen = false; ! 349: Change_CopyChangedParamsToConfiguration(¤t, &ConfigureParams, false); ! 350: } ! 351: else ! 352: { ! 353: ConfigureParams = current; ! 354: } ! 355: ! 356: return DEBUGGER_CMDDONE; ! 357: } ! 358: ! 359: ! 360: /** ! 361: * Command: Set tracing ! 362: */ ! 363: static int DebugUI_SetTracing(int argc, char *argv[]) ! 364: { ! 365: const char *errstr; ! 366: if (argc != 2) ! 367: { ! 368: DebugUI_PrintCmdHelp(argv[0]); ! 369: return DEBUGGER_CMDDONE; ! 370: } ! 371: errstr = Log_SetTraceOptions(argv[1]); ! 372: if (errstr && errstr[0]) ! 373: fprintf(stderr, "ERROR: %s\n", errstr); ! 374: ! 375: return DEBUGGER_CMDDONE; ! 376: } ! 377: ! 378: ! 379: /** ! 380: * Command: Change Hatari work directory ! 381: */ ! 382: static int DebugUI_ChangeDir(int argc, char *argv[]) ! 383: { ! 384: if (argc == 2) ! 385: { ! 386: if (chdir(argv[1]) == 0) ! 387: return DEBUGGER_CMDDONE; ! 388: perror("ERROR"); ! 389: } ! 390: DebugUI_PrintCmdHelp(argv[0]); ! 391: return DEBUGGER_CMDDONE; ! 392: } ! 393: ! 394: ! 395: /** ! 396: * Command: Read debugger commands from a file ! 397: */ ! 398: static int DebugUI_CommandsFromFile(int argc, char *argv[]) ! 399: { ! 400: if (argc == 2) ! 401: DebugUI_ParseFile(argv[1]); ! 402: else ! 403: DebugUI_PrintCmdHelp(argv[0]); ! 404: return DEBUGGER_CMDDONE; ! 405: } ! 406: ! 407: ! 408: /** ! 409: * Command: Execute a system command ! 410: */ ! 411: #if ENABLE_SYSTEM_DEBUG_CALL /* Disabled by default - could be a security risk? */ ! 412: static int DebugUI_Exec(int argc, char *argv[]) ! 413: { ! 414: if (argc == 2) ! 415: { ! 416: int ret = system(argv[1]); ! 417: if (ret) ! 418: { ! 419: /* error -> show return code */ ! 420: fprintf(stderr, "Error code = %d\n", ret); ! 421: } ! 422: } ! 423: else ! 424: DebugUI_PrintCmdHelp(argv[0]); ! 425: return DEBUGGER_CMDDONE; ! 426: } ! 427: #endif ! 428: ! 429: ! 430: /** ! 431: * Command: Quit emulator ! 432: */ ! 433: static int DebugUI_QuitEmu(int nArgc, char *psArgv[]) ! 434: { ! 435: bQuitProgram = true; ! 436: M68000_SetSpecial(SPCFLAG_BRK); /* Assure that CPU core shuts down */ ! 437: return DEBUGGER_END; ! 438: } ! 439: ! 440: ! 441: /** ! 442: * Print help text for one command ! 443: */ ! 444: void DebugUI_PrintCmdHelp(const char *psCmd) ! 445: { ! 446: dbgcommand_t *cmd; ! 447: int i; ! 448: ! 449: /* Search the command ... */ ! 450: for (cmd = debugCommand, i = 0; i < debugCommands; i++, cmd++) ! 451: { ! 452: if (!debugCommand[i].pFunction) ! 453: continue; ! 454: if ((*(cmd->sShortName) && !strcmp(psCmd, cmd->sShortName)) ! 455: || !strcmp(psCmd, cmd->sLongName)) ! 456: { ! 457: bool bShort = *(cmd->sShortName); ! 458: /* ... and print help text */ ! 459: if (bShort) ! 460: { ! 461: fprintf(stderr, "'%s' or '%s' - %s\n", ! 462: cmd->sLongName, ! 463: cmd->sShortName, ! 464: cmd->sShortDesc); ! 465: } ! 466: else ! 467: { ! 468: fprintf(stderr, "'%s' - %s\n", ! 469: cmd->sLongName, ! 470: cmd->sShortDesc); ! 471: } ! 472: fprintf(stderr, "Usage: %s %s\n", ! 473: bShort ? cmd->sShortName : cmd->sLongName, ! 474: cmd->sUsage); ! 475: return; ! 476: } ! 477: } ! 478: ! 479: fprintf(stderr, "Unknown command '%s'\n", psCmd); ! 480: } ! 481: ! 482: ! 483: /** ! 484: * Command: Print debugger help screen. ! 485: */ ! 486: static int DebugUI_Help(int nArgc, char *psArgs[]) ! 487: { ! 488: int i; ! 489: ! 490: if (nArgc > 1) ! 491: { ! 492: DebugUI_PrintCmdHelp(psArgs[1]); ! 493: return DEBUGGER_CMDDONE; ! 494: } ! 495: ! 496: for (i = 0; i < debugCommands; i++) ! 497: { ! 498: if (!debugCommand[i].pFunction) ! 499: { ! 500: fprintf(stderr, "\n%s:\n", debugCommand[i].sLongName); ! 501: continue; ! 502: } ! 503: fprintf(stderr, " %12s (%2s) : %s\n", debugCommand[i].sLongName, ! 504: debugCommand[i].sShortName, debugCommand[i].sShortDesc); ! 505: } ! 506: ! 507: fprintf(stderr, ! 508: "\n" ! 509: "If value is prefixed with '$', it's a hexadecimal, if with '#', it's\n" ! 510: "a normal decimal, if with '%%', it's a binary decimal. Prefix can\n" ! 511: "be skipped for numbers in the default number base (currently %d).\n" ! 512: "\n" ! 513: "Any expression given in quotes (within \"\"), will be evaluated\n" ! 514: "before given to the debugger command. Any register and symbol\n" ! 515: "names in the expression are replaced by their values.\n" ! 516: "\n" ! 517: "Note that address ranges like '$fc0000-$fc0100' should have no\n" ! 518: "spaces between the range numbers.\n" ! 519: "\n" ! 520: "'help <command>' gives more help.\n", ConfigureParams.Debugger.nNumberBase); ! 521: return DEBUGGER_CMDDONE; ! 522: } ! 523: ! 524: ! 525: /** ! 526: * Parse debug command and execute it. ! 527: */ ! 528: static int DebugUI_ParseCommand(char *input) ! 529: { ! 530: char *psArgs[64]; ! 531: const char *delim; ! 532: static char sLastCmd[80] = { '\0' }; ! 533: int nArgc, cmd = -1; ! 534: int i, retval; ! 535: ! 536: psArgs[0] = strtok(input, " \t"); ! 537: ! 538: if (psArgs[0] == NULL) ! 539: { ! 540: if (strlen(sLastCmd) > 0) ! 541: psArgs[0] = sLastCmd; ! 542: else ! 543: return DEBUGGER_CMDDONE; ! 544: } ! 545: ! 546: /* Search the command ... */ ! 547: for (i = 0; i < debugCommands; i++) ! 548: { ! 549: if (!debugCommand[i].pFunction) ! 550: continue; ! 551: if (!strcmp(psArgs[0], debugCommand[i].sShortName) || ! 552: !strcmp(psArgs[0], debugCommand[i].sLongName)) ! 553: { ! 554: cmd = i; ! 555: break; ! 556: } ! 557: } ! 558: if (cmd == -1) ! 559: { ! 560: fprintf(stderr, "Command '%s' not found.\n" ! 561: "Use 'help' to view a list of available commands.\n", ! 562: psArgs[0]); ! 563: return DEBUGGER_CMDDONE; ! 564: } ! 565: ! 566: if (debugCommand[cmd].bNoParsing) ! 567: delim = ""; ! 568: else ! 569: delim = " \t"; ! 570: ! 571: /* Separate arguments and put the pointers into psArgs */ ! 572: for (nArgc = 1; nArgc < ARRAYSIZE(psArgs); nArgc++) ! 573: { ! 574: psArgs[nArgc] = strtok(NULL, delim); ! 575: if (psArgs[nArgc] == NULL) ! 576: break; ! 577: } ! 578: ! 579: if (!debugOutput) { ! 580: /* make sure also calls from control.c work */ ! 581: DebugUI_SetLogDefault(); ! 582: } ! 583: ! 584: /* ... and execute the function */ ! 585: retval = debugCommand[i].pFunction(nArgc, psArgs); ! 586: /* Save commando string if it can be repeated */ ! 587: if (retval == DEBUGGER_CMDCONT) ! 588: strncpy(sLastCmd, psArgs[0], sizeof(sLastCmd)); ! 589: else ! 590: sLastCmd[0] = '\0'; ! 591: return retval; ! 592: } ! 593: ! 594: ! 595: /* See "info:readline" e.g. in Konqueror for readline usage. */ ! 596: ! 597: /** ! 598: * Readline match callback for long command name completion. ! 599: * STATE = 0 -> different text from previous one. ! 600: * Return next match or NULL if no matches. ! 601: */ ! 602: static char *DebugUI_MatchCommand(const char *text, int state) ! 603: { ! 604: static int i, len; ! 605: const char *name; ! 606: ! 607: if (!state) ! 608: { ! 609: /* first match */ ! 610: len = strlen(text); ! 611: i = 0; ! 612: } ! 613: /* next match */ ! 614: while (i < debugCommands) ! 615: { ! 616: name = debugCommand[i].sLongName; ! 617: if (debugCommand[i++].pFunction && ! 618: strncmp(name, text, len) == 0) ! 619: return (strdup(name)); ! 620: } ! 621: return NULL; ! 622: } ! 623: ! 624: ! 625: #if HAVE_LIBREADLINE ! 626: /** ! 627: * Readline match callback returning last result. ! 628: */ ! 629: static char *DebugUI_MatchLast(const char *text, int state) ! 630: { ! 631: if (state) ! 632: return NULL; ! 633: return strdup(lastResult); ! 634: } ! 635: ! 636: /** ! 637: * Readline completion callback. Returns matches. ! 638: */ ! 639: static char **DebugUI_Completion(const char *text, int a, int b) ! 640: { ! 641: int i, cmd, quotes, end, start = 0; ! 642: char *str, buf[32]; ! 643: size_t len; ! 644: ! 645: /* check where's the first word (ignore white space) */ ! 646: while (start < rl_point && isspace(rl_line_buffer[start])) ! 647: start++; ! 648: end = start; ! 649: while (end < rl_point && !isspace(rl_line_buffer[end])) ! 650: end++; ! 651: ! 652: if (end >= rl_point) ! 653: /* first word on line */ ! 654: return rl_completion_matches(text, DebugUI_MatchCommand); ! 655: ! 656: /* complete '$' with last result? */ ! 657: if (lastResult[0] && rl_line_buffer[rl_point-1] == '$') ! 658: return rl_completion_matches(text, DebugUI_MatchLast); ! 659: ! 660: /* check which command args are to be completed */ ! 661: len = end - start; ! 662: if (len >= sizeof(buf)) ! 663: len = sizeof(buf)-1; ! 664: memcpy(buf, &(rl_line_buffer[start]), len); ! 665: buf[len] = '\0'; ! 666: ! 667: /* expression completion needed (= open quote)? */ ! 668: str = strchr(&(rl_line_buffer[end]), '"'); ! 669: quotes = 0; ! 670: while (str) ! 671: { ! 672: quotes++; ! 673: str = strchr(str+1, '"'); ! 674: } ! 675: if (quotes & 1) ! 676: { ! 677: if (DebugUI_IsForDsp(buf)) ! 678: return rl_completion_matches(text, Symbols_MatchDspAddress); ! 679: return rl_completion_matches(text, Symbols_MatchCpuAddress); ! 680: } ! 681: ! 682: /* do command argument completion */ ! 683: cmd = -1; ! 684: for (i = 0; i < debugCommands; i++) ! 685: { ! 686: if (!debugCommand[i].pFunction) ! 687: continue; ! 688: if (!strcmp(buf, debugCommand[i].sShortName) || ! 689: !strcmp(buf, debugCommand[i].sLongName)) ! 690: { ! 691: cmd = i; ! 692: break; ! 693: } ! 694: } ! 695: if (cmd < 0) ! 696: { ! 697: rl_attempted_completion_over = true; ! 698: return NULL; ! 699: } ! 700: if (debugCommand[cmd].pMatch) ! 701: return rl_completion_matches(text, debugCommand[cmd].pMatch); ! 702: else ! 703: return rl_completion_matches(text, rl_filename_completion_function); ! 704: } ! 705: ! 706: ! 707: /** ! 708: * Read a command line from the keyboard and return a pointer to the string. ! 709: * @return Pointer to the string which should be deallocated free() ! 710: * after use. Returns NULL when error occured. ! 711: */ ! 712: static char *DebugUI_GetCommand(void) ! 713: { ! 714: char *input; ! 715: ! 716: /* Allow conditional parsing of the ~/.inputrc file. */ ! 717: rl_readline_name = "Hatari"; ! 718: ! 719: /* Tell the completer that we want a crack first. */ ! 720: rl_attempted_completion_function = DebugUI_Completion; ! 721: ! 722: input = readline("> "); ! 723: if (!input) ! 724: return NULL; ! 725: ! 726: input = Str_Trim(input); ! 727: if (input[0]) ! 728: add_history(input); ! 729: ! 730: return input; ! 731: } ! 732: ! 733: #else /* !HAVE_LIBREADLINE */ ! 734: ! 735: /** ! 736: * Read a command line from the keyboard and return a pointer to the string. ! 737: * @return Pointer to the string which should be deallocated free() ! 738: * after use. Returns NULL when error occured. ! 739: */ ! 740: static char *DebugUI_GetCommand(void) ! 741: { ! 742: char *input; ! 743: fprintf(stderr, "> "); ! 744: input = malloc(256); ! 745: if (!input) ! 746: return NULL; ! 747: input[0] = '\0'; ! 748: if (fgets(input, 256, stdin) == NULL) ! 749: { ! 750: free(input); ! 751: return NULL; ! 752: } ! 753: return Str_Trim(input); ! 754: } ! 755: ! 756: #endif /* !HAVE_LIBREADLINE */ ! 757: ! 758: ! 759: static const dbgcommand_t uicommand[] = ! 760: { ! 761: { NULL, NULL, "Generic commands", NULL, NULL, NULL, false }, ! 762: /* NULL as match function will complete file names */ ! 763: { DebugUI_ChangeDir, NULL, ! 764: "cd", "", ! 765: "change directory", ! 766: "<directory>\n" ! 767: "\tChange Hatari work directory.", ! 768: false }, ! 769: { DebugUI_Evaluate, Symbols_MatchCpuAddress, ! 770: "evaluate", "e", ! 771: "evaluate an expression", ! 772: "<expression>\n" ! 773: "\tEvaluate an expression and show the result. Expression can\n" ! 774: "\tinclude CPU register and symbol names, those are replaced\n" ! 775: "\tby their values. Supported operators in expressions are,\n" ! 776: "\tin the decending order of precedence:\n" ! 777: "\t\t(), +, -, ~, *, /, +, -, >>, <<, ^, &, |\n" ! 778: "\tFor example:\n" ! 779: "\t\t((0x21 * 0x200) + (-5)) ^ (~%111 & $f0f0f0)\n" ! 780: "\tResult value is shown as binary, decimal and hexadecimal.\n" ! 781: "\tAfter this, '$' will TAB-complete to last result value.", ! 782: true }, ! 783: #if ENABLE_SYSTEM_DEBUG_CALL ! 784: { DebugUI_Exec, NULL, ! 785: "exec", "", ! 786: "execute a shell command", ! 787: "<command line>\n" ! 788: "\tRun the given command with the system shell.", ! 789: true }, ! 790: #endif ! 791: { DebugUI_Help, DebugUI_MatchCommand, ! 792: "help", "h", ! 793: "print help", ! 794: "[command]\n" ! 795: "\tPrint help text for available commands.", ! 796: false }, ! 797: { DebugInfo_Command, DebugInfo_MatchInfo, ! 798: "info", "i", ! 799: "show machine/OS information", ! 800: "[subject [arg]]\n" ! 801: "\tPrint information on requested subject or list them if\n" ! 802: "\tno subject given.", ! 803: false }, ! 804: { DebugInfo_Command, DebugInfo_MatchLock, ! 805: "lock", "", ! 806: "lock info to show on entering debugger", ! 807: "[subject [args]]\n" ! 808: "\tLock requested information to be shown every time debugger\n" ! 809: "\tis entered or list available options if no subject's given.", ! 810: false }, ! 811: { DebugUI_SetLogFile, NULL, ! 812: "logfile", "f", ! 813: "open or close log file", ! 814: "[filename]\n" ! 815: "\tOpen log file, no argument closes the log file. Output of\n" ! 816: "\tregister & memory dumps and disassembly will be written to it.", ! 817: false }, ! 818: { DebugUI_CommandsFromFile, NULL, ! 819: "parse", "p", ! 820: "get debugger commands from file", ! 821: "[filename]\n" ! 822: "\tRead debugger commands from given file and do them.", ! 823: false }, ! 824: { DebugUI_SetOptions, Opt_MatchOption, ! 825: "setopt", "o", ! 826: "set Hatari command line and debugger options", ! 827: "[<bin|dec|hex>|<command line options>]\n" ! 828: "\tSet Hatari options. For example to enable exception catching,\n" ! 829: "\tuse following command line option: 'setopt --debug'. Special\n" ! 830: "\t'bin', 'dec' and 'hex' arguments change the default number base\n" ! 831: "\tused in debugger.", ! 832: false }, ! 833: { DebugUI_DoMemorySnap, NULL, ! 834: "stateload", "", ! 835: "restore emulation state", ! 836: "[filename]\n" ! 837: "\tRestore emulation snapshot from default or given file", ! 838: false }, ! 839: { DebugUI_DoMemorySnap, NULL, ! 840: "statesave", "", ! 841: "save emulation state", ! 842: "[filename]\n" ! 843: "\tSave emulation snapshot to default or given file", ! 844: false }, ! 845: { DebugUI_SetTracing, Log_MatchTrace, ! 846: "trace", "t", ! 847: "select Hatari tracing settings", ! 848: "[set1,set2...]\n" ! 849: "\tSelect Hatari tracing settings. For example to enable CPU\n" ! 850: "\tdisassembly and VBL tracing, use: trace cpu_disasm,video_hbl", ! 851: false }, ! 852: { DebugUI_QuitEmu, NULL, ! 853: "quit", "q", ! 854: "quit emulator", ! 855: "\n" ! 856: "\tLeave debugger and quit emulator.", ! 857: false } ! 858: }; ! 859: ! 860: ! 861: /** ! 862: * Debugger user interface initialization. ! 863: */ ! 864: void DebugUI_Init(void) ! 865: { ! 866: const dbgcommand_t *cpucmd, *dspcmd; ! 867: int cpucmds, dspcmds; ! 868: ! 869: /* already intialized? */ ! 870: if (debugCommands) ! 871: return; ! 872: ! 873: /* if you want disassembly or memdumping to start/continue from ! 874: * specific address, you can set them in these functions. ! 875: */ ! 876: // dspcmds = DebugDsp_Init(&dspcmd); ! 877: cpucmds = DebugCpu_Init(&cpucmd); ! 878: ! 879: /* on first time copy the command structures to a single table */ ! 880: debugCommands = ARRAYSIZE(uicommand); ! 881: debugCommand = malloc(sizeof(dbgcommand_t) * (cpucmds + debugCommands)); ! 882: assert(debugCommand); ! 883: ! 884: memcpy(debugCommand, uicommand, sizeof(dbgcommand_t) * debugCommands); ! 885: memcpy(&debugCommand[debugCommands], cpucmd, sizeof(dbgcommand_t) * cpucmds); ! 886: debugCommands += cpucmds; ! 887: // memcpy(&debugCommand[debugCommands], dspcmd, sizeof(dbgcommand_t) * dspcmds); ! 888: // debugCommands += dspcmds; ! 889: ! 890: if (parseFileName) ! 891: DebugUI_ParseFile(parseFileName); ! 892: } ! 893: ! 894: ! 895: /** ! 896: * Set debugger commands file. ! 897: * Return true if file exists, false otherwise. ! 898: */ ! 899: bool DebugUI_SetParseFile(const char *path) ! 900: { ! 901: if (File_Exists(path)) ! 902: { ! 903: parseFileName = path; ! 904: return true; ! 905: } ! 906: fprintf(stderr, "ERROR: debugger input file '%s' missing.\n", path); ! 907: return false; ! 908: } ! 909: ! 910: ! 911: /** ! 912: * Debugger user interface main function. ! 913: */ ! 914: void DebugUI(void) ! 915: { ! 916: int cmdret, alertLevel; ! 917: char *psCmd; ! 918: static const char *welcome = ! 919: "\n----------------------------------------------------------------------" ! 920: "\nYou have entered debug mode. Type c to continue emulation, h for help.\n"; ! 921: ! 922: if (bInFullScreen) ! 923: Screen_ReturnFromFullScreen(); ! 924: ! 925: DebugUI_Init(); ! 926: ! 927: if (welcome) ! 928: { ! 929: fputs(welcome, stderr); ! 930: welcome = NULL; ! 931: } ! 932: DebugCpu_InitSession(); ! 933: // DebugDsp_InitSession(); ! 934: DebugInfo_ShowSessionInfo(); ! 935: ! 936: /* override paused message so that user knows to look into console ! 937: * on how to continue in case he invoked the debugger by accident. ! 938: */ ! 939: Statusbar_AddMessage("Console Debugger", 100); ! 940: Statusbar_Update(sdlscrn); ! 941: ! 942: /* disable normal GUI alerts while on console */ ! 943: alertLevel = Log_SetAlertLevel(LOG_FATAL); ! 944: ! 945: cmdret = DEBUGGER_CMDDONE; ! 946: do ! 947: { ! 948: /* Read command from the keyboard */ ! 949: psCmd = DebugUI_GetCommand(); ! 950: if (!psCmd) ! 951: break; ! 952: ! 953: /* expand all quoted expressions */ ! 954: if (!(psCmd = DebugUI_EvaluateExpressions(psCmd))) ! 955: continue; ! 956: ! 957: /* Parse and execute the command string */ ! 958: cmdret = DebugUI_ParseCommand(psCmd); ! 959: free(psCmd); ! 960: } ! 961: while (cmdret != DEBUGGER_END); ! 962: ! 963: Log_SetAlertLevel(alertLevel); ! 964: DebugUI_SetLogDefault(); ! 965: ! 966: DebugCpu_SetDebugging(); ! 967: } ! 968: ! 969: ! 970: /** ! 971: * Read debugger commands from a file. ! 972: * return false for error, true for success. ! 973: */ ! 974: static bool DebugUI_ParseFile(const char *path) ! 975: { ! 976: char *dir, *cmd, *input, *slash; ! 977: FILE *fp; ! 978: ! 979: fprintf(stderr, "Reading debugger commands from '%s'...\n", path); ! 980: if (!(fp = fopen(path, "r"))) ! 981: { ! 982: perror("ERROR"); ! 983: return false; ! 984: } ! 985: ! 986: /* change to directory where the debugger file resides */ ! 987: dir = strdup(path); ! 988: slash = strrchr(dir, PATHSEP); ! 989: if (slash) ! 990: { ! 991: *slash = '\0'; ! 992: if (chdir(dir)) ! 993: { ! 994: perror("ERROR"); ! 995: free(dir); ! 996: return false; ! 997: } ! 998: } ! 999: free(dir); ! 1000: ! 1001: input = NULL; ! 1002: for (;;) ! 1003: { ! 1004: if (!input) ! 1005: { ! 1006: input = malloc(256); ! 1007: assert(input); ! 1008: } ! 1009: if (!fgets(input, 256, fp)) ! 1010: break; ! 1011: ! 1012: input = DebugUI_EvaluateExpressions(input); ! 1013: if (!input) ! 1014: continue; ! 1015: ! 1016: cmd = Str_Trim(input); ! 1017: if (*cmd && *cmd != '#') ! 1018: { ! 1019: fprintf(stderr, "> %s\n", cmd); ! 1020: DebugUI_ParseCommand(cmd); ! 1021: } ! 1022: } ! 1023: ! 1024: free(input); ! 1025: ! 1026: DebugCpu_SetDebugging(); ! 1027: // DebugDsp_SetDebugging(); ! 1028: return true; ! 1029: } ! 1030: ! 1031: ! 1032: /** ! 1033: * Remote/parallel debugger usage API. ! 1034: * Return false for failed command, true for success. ! 1035: */ ! 1036: bool DebugUI_RemoteParse(char *input) ! 1037: { ! 1038: int ret; ! 1039: ! 1040: DebugUI_Init(); ! 1041: ! 1042: ret = DebugUI_ParseCommand(input); ! 1043: ! 1044: DebugCpu_SetDebugging(); ! 1045: // DebugDsp_SetDebugging(); ! 1046: ! 1047: return (ret == DEBUGGER_CMDDONE); ! 1048: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.