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