Mercurial > repos > blastem

annotate debug.c @ 2188:e17d99c96c89

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
author Michael Pavone <pavone@retrodev.com>
date Sat, 20 Aug 2022 11:40:41 -0700
parents d0129f19ca52
children 6b33ce6bc740
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 #include "debug.h"
1103
22e87b739ad6 WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents: 985
diff changeset
2 #include "genesis.h"
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 #include "68kinst.h"
2104
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
4 #include "segacd.h"
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
5 #include "blastem.h"
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
6 #include "bindings.h"
2177
44596610b2a0 Fix Windows build
Michael Pavone <pavone@retrodev.com>
parents: 2175
diff changeset
7 #include <ctype.h>
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 #include <stdlib.h>
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 #include <string.h>
745
daa31ee7d8cd Get windows build compiling again post-merge
Michael Pavone <pavone@retrodev.com>
parents: 723
diff changeset
10 #ifndef _WIN32
723
7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger
Michael Pavone <pavone@retrodev.com>
parents: 707
diff changeset
11 #include <sys/select.h>
745
daa31ee7d8cd Get windows build compiling again post-merge
Michael Pavone <pavone@retrodev.com>
parents: 723
diff changeset
12 #endif
723
7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger
Michael Pavone <pavone@retrodev.com>
parents: 707
diff changeset
13 #include "render.h"
792
724bbec47f86 Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents: 747
diff changeset
14 #include "util.h"
794
792be135d3af Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents: 792
diff changeset
15 #include "terminal.h"
1752
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
16 #include "z80inst.h"
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
17
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
18 #ifdef NEW_CORE
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
19 #define Z80_OPTS opts
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
20 #else
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
21 #define Z80_OPTS options
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
22 #endif
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
24 static debug_root roots[5];
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
25 static uint32_t num_roots;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
26 #define MAX_DEBUG_ROOTS (sizeof(roots)/sizeof(*roots))
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
27
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
28 debug_root *find_root(void *cpu)
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
29 {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
30 for (uint32_t i = 0; i < num_roots; i++)
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
31 {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
32 if (roots[i].cpu_context == cpu) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
33 return roots + i;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
34 }
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
35 }
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
36 if (num_roots < MAX_DEBUG_ROOTS) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
37 num_roots++;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
38 memset(roots + num_roots - 1, 0, sizeof(debug_root));
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
39 roots[num_roots-1].cpu_context = cpu;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
40 return roots + num_roots - 1;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
41 }
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
42 return NULL;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
43 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 bp_def ** find_breakpoint(bp_def ** cur, uint32_t address)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 while (*cur) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 if ((*cur)->address == address) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 cur = &((*cur)->next);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 return cur;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56 bp_def ** find_breakpoint_idx(bp_def ** cur, uint32_t index)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
57 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
58 while (*cur) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 if ((*cur)->index == index) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
60 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 cur = &((*cur)->next);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 return cur;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
67 static const char *token_type_names[] = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
68 "TOKEN_NONE",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
69 "TOKEN_NUM",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
70 "TOKEN_NAME",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
71 "TOKEN_OPER",
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
72 "TOKEN_SIZE",
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
73 "TOKEN_LBRACKET",
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
74 "TOKEN_RBRACKET",
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
75 "TOKEN_LPAREN",
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
76 "TOKEN_RPAREN"
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
77 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
78
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
79 static token parse_token(char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
80 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
81 while(*start && isblank(*start) && *start != '\n' && *start != '\r')
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
82 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
83 ++start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
84 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
85 if (!*start || *start == '\n' || *start == '\r') {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
86 return (token){
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
87 .type = TOKEN_NONE
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
88 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
89 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
90 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
91 if (*start == '$' || (*start == '0' && start[1] == 'x')) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
92 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
93 .type = TOKEN_NUM,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
94 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
95 .num = strtol(start + (*start == '$' ? 1 : 2), end, 16)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
96 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
97 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
98 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
99 if (isdigit(*start)) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
100 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
101 .type = TOKEN_NUM,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
102 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
103 .num = strtol(start, end, 10)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
104 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
105 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
106 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
107 switch (*start)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
108 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
109 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
110 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
111 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
112 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
113 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
114 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
115 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
116 case '~':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
117 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
118 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
119 if (*start == '!' && start[1] == '=') {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
120 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
121 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
122 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
123 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
124 .op = {*start, start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
125 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
126 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
127 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
128 *end = start + 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
129 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
130 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
131 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
132 .op = {*start, 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
133 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
134 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
135 case '.':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
136 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
137 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
138 .type = TOKEN_SIZE,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
139 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
140 .op = {start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
141 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
142 };
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
143 case '[':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
144 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
145 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
146 .type = TOKEN_LBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
147 };
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
148 case ']':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
149 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
150 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
151 .type = TOKEN_RBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
152 };
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
153 case '(':
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
154 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
155 return (token) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
156 .type = TOKEN_LPAREN
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
157 };
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
158 case ')':
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
159 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
160 return (token) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
161 .type = TOKEN_RPAREN
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
162 };
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
163 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
164 *end = start + 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
165 while (**end && !isspace(**end))
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
166 {
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
167 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
168 switch (**end)
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
169 {
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
170 case '+':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
171 case '-':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
172 case '*':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
173 case '/':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
174 case '&':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
175 case '|':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
176 case '^':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
177 case '~':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
178 case '=':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
179 case '!':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
180 case '.':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
181 done = 1;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
182 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
183 }
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
184 if (done) {
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
185 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
186 }
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
187
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
188 ++*end;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
189 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
190 char *name = malloc(*end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
191 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
192 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
193 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
194 .type = TOKEN_NAME,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
195 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
196 .str = name
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
197 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
198 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
199 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
200
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
201 static void free_expr(expr *e)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
202 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
203 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
204 return;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
205 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
206 free_expr(e->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
207 free_expr(e->right);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
208 if (e->op.type == TOKEN_NAME) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
209 free(e->op.v.str);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
210 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
211 free(e);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
212 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
213
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
214 static expr *parse_scalar_or_muldiv(char *start, char **end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
215 static expr *parse_expression(char *start, char **end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
216
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
217 static expr *parse_scalar(char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
218 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
219 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
220 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
221 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
222 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
223 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
224 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
225 fprintf(stderr, "Unexpected TOKEN_SIZE '.%s'\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
226 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
227 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
228 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
229 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
230 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
231 fprintf(stderr, "Unary expression %s needs value\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
232 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
233 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
234 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
235 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
236 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
237 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
238 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
239 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
240 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
241 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
242 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
243 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
244 ret->left = parse_expression(after_first, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
245 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
246 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
247 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
248 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
249 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
250 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
251 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
252 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
253 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
254 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
255 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
256 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
257 token size = parse_token(*end, &after_size);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
258 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
259 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
260 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
261 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
262 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
263 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
264 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
265 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
266 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
267 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
268 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
269 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
270 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
271 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
272 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
273 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
274 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
275 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
276 return ret;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
277 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
278 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
279 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
280 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
281 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
282 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
283 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
284 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
285 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
286 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
287 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
288 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
289 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
290 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
291 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
292 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
293 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
294 ret->left->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
295 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
296 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
297 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
298
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
299 static expr *maybe_binary(expr *left, char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
300 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
301 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
302 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
303 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
304 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
305 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
306 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
307 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
308 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
309 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
310 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
311 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
312 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
313 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
314 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
315 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
316 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
317 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
318 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
319 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
320 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
321 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
322 bin->right = parse_scalar_or_muldiv(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
323 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
324 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
325 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
326 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
327 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
328 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
329 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
330 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
331 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
332 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
333 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
334
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
335 static expr *maybe_muldiv(expr *left, char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
336 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
337 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
338 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
339 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
340 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
341 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
342 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
343 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
344 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
345 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
346 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
347 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
348 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
349 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
350 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
351 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
352 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
353 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
354 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
355 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
356 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
357 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
358 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
359 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
360 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
361 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
362
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
363 static expr *parse_scalar_or_muldiv(char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
364 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
365 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
366 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
367 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
368 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
369 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
370 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
371 fprintf(stderr, "Unexpected TOKEN_SIZE '.%s'\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
372 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
373 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
374 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
375 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
376 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
377 fprintf(stderr, "Unary expression %s needs value\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
378 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
379 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
380 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
381 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
382 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
383 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
384 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
385 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
386 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
387 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
388 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
389 ret->left = parse_expression(after_first, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
390 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
391 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
392 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
393 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
394 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
395 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
396 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
397 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
398 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
399 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
400 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
401 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
402 token size = parse_token(*end, &after_size);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
403 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
404 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
405 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
406 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
407 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
408 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
409 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
410 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
411 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
412 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
413 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
414 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
415 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
416 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
417 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
418 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
419 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
420 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
421 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
422 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
423 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
424 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
425 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
426 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
427 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
428 token second = parse_token(after_first, &after_second);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
429 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
430 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
431 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
432 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
433 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
434 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
435 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
436 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
437 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
438 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
439 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
440 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
441 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
442 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
443 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
444 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
445 return maybe_muldiv(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
446 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
447 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
448 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
449 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
450 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
451 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
452 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
453 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
454 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
455 fprintf(stderr, "%s is not a valid binary operator\n", second.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
456 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
457 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
458 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
459 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
460 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
461 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
462 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
463 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
464 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
465 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
466 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
467 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
468 } else {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
469 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
470 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
471 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
472 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
473 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
474 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
475 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
476
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
477 static expr *parse_expression(char *start, char **end)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
478 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
479 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
480 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
481 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
482 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
483 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
484 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
485 fprintf(stderr, "Unexpected TOKEN_SIZE '.%s'\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
486 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
487 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
488 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
489 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
490 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
491 fprintf(stderr, "Unary expression %s needs value\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
492 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
493 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
494 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
495 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
496 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
497 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
498 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
499 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
500 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
501 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
502 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
503 ret->left = parse_expression(after_first, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
504 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
505 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
506 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
507 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
508 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
509 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
510 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
511 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
512 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
513 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
514 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
515 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
516 token size = parse_token(*end, &after_size);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
517 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
518 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
519 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
520 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
521 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
522 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
523 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
524 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
525 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
526 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
527 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
528 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
529 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
530 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
531 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
532 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
533 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
534 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
535 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
536 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
537 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
538 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
539 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
540 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
541 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
542 token second = parse_token(after_first, &after_second);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
543 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
544 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
545 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
546 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
547 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
548 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
549 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
550 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
551 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
552 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
553 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
554 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
555 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
556 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
557 bin->right = parse_scalar(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
558 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
559 fprintf(stderr, "Expected expression to the right of %s\n", second.v.op);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
560 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
561 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
562 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
563 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
564 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
565 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
566 bin->right = parse_scalar_or_muldiv(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
567 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
568 fprintf(stderr, "Expected expression to the right of %s\n", second.v.op);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
569 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
570 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
571 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
572 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
573 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
574 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
575 bin->right = parse_expression(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
576 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
577 fprintf(stderr, "Expected expression to the right of %s\n", second.v.op);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
578 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
579 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
580 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
581 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
582 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
583 fprintf(stderr, "%s is not a valid binary operator\n", second.v.op);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
584 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
585 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
586 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
587 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
588 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
589 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
590 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
591 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
592 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
593 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
594 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
595 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
596 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
597 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
598 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
599 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
600 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
601 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
602 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
603 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
604 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
605 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
606 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
607
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
608 uint8_t eval_expr(debug_root *root, expr *e, uint32_t *out)
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
609 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
610 uint32_t right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
611 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
612 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
613 case EXPR_SCALAR:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
614 if (e->op.type == TOKEN_NAME) {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
615 return root->resolve(root, e->op.v.str, out);
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
616 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
617 *out = e->op.v.num;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
618 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
619 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
620 case EXPR_UNARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
621 if (!eval_expr(root, e->left, out)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
622 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
623 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
624 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
625 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
626 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
627 *out = !*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
628 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
629 case '~':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
630 *out = ~*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
631 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
632 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
633 *out = -*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
634 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
635 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
636 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
637 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
638 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
639 case EXPR_BINARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
640 if (!eval_expr(root, e->left, out) || !eval_expr(root, e->right, &right)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
641 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
642 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
643 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
644 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
645 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
646 *out += right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
647 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
648 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
649 *out -= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
650 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
651 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
652 *out *= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
653 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
654 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
655 *out /= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
656 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
657 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
658 *out &= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
659 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
660 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
661 *out |= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
662 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
663 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
664 *out ^= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
665 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
666 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
667 *out = *out == right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
668 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
669 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
670 *out = *out != right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
671 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
672 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
673 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
674 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
675 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
676 case EXPR_SIZE:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
677 if (!eval_expr(root, e->left, out)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
678 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
679 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
680 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
681 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
682 case 'b':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
683 *out &= 0xFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
684 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
685 case 'w':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
686 *out &= 0xFFFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
687 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
688 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
689 return 1;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
690 case EXPR_MEM:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
691 if (!eval_expr(root, e->left, out)) {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
692 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
693 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
694 return root->read_mem(root, out, e->op.v.op[0]);
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
695 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
696 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
697 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
698 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
699
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
700 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
701 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
702 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
703 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
704 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
705 return buf+1;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
706 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
707 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
708 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
709 return NULL;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
710 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
711
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
712 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
713 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
714 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
715 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
716 *buf = 0;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
717 return;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
718 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
719 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
720 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
721
1965
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
722 static uint8_t m68k_read_byte(uint32_t address, m68k_context *context)
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
723 {
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
724 //TODO: share this implementation with GDB debugger
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
725 return read_byte(address, (void **)context->mem_pointers, &context->options->gen, context);
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
726 }
3a46ff899fa6 More correct implementation of byte printing in builtin debugger. Fix GDB debugger to use helper in backend.c for reading bytes
Michael Pavone <pavone@retrodev.com>
parents: 1963
diff changeset
727
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
728 static uint16_t m68k_read_word(uint32_t address, m68k_context *context)
1313
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
729 {
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
730 return read_word(address, (void **)context->mem_pointers, &context->options->gen, context);
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
731 }
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
732
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
733 static uint32_t m68k_read_long(uint32_t address, m68k_context *context)
1313
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
734 {
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
735 return m68k_read_word(address, context) << 16 | m68k_read_word(address + 2, context);
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
736 }
b27d7bf1107e Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents: 1312
diff changeset
737
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
738 static uint8_t read_m68k(debug_root *root, uint32_t *out, char size)
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
739 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
740 m68k_context *context = root->cpu_context;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
741 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
742 *out = m68k_read_byte(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
743 } else if (size == 'l') {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
744 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
745 fprintf(stderr, "Longword access to odd addresses (%X) is not allowed\n", *out);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
746 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
747 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
748 *out = m68k_read_long(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
749 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
750 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
751 fprintf(stderr, "Wword access to odd addresses (%X) is not allowed\n", *out);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
752 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
753 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
754 *out = m68k_read_word(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
755 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
756 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
757 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
758
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
759 static uint8_t write_m68k(debug_root *root, uint32_t address, uint32_t value, char size)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
760 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
761 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
762 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
763 write_byte(address, value, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
764 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
765 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
766 fprintf(stderr, "Longword access to odd addresses (%X) is not allowed\n", address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
767 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
768 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
769 write_word(address, value >> 16, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
770 write_word(address + 2, value, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
771 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
772 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
773 fprintf(stderr, "Wword access to odd addresses (%X) is not allowed\n", address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
774 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
775 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
776 write_word(address, value, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
777 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
778 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
779 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
780
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
781 static uint8_t resolve_m68k(debug_root *root, const char *name, uint32_t *out)
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
782 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
783 m68k_context *context = root->cpu_context;
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
784 if ((name[0] == 'd' || name[0] == 'D') && name[1] >= '0' && name[1] <= '7' && !name[2]) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
785 *out = context->dregs[name[1]-'0'];
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
786 } else if ((name[0] == 'a' || name[0] == 'A') && name[1] >= '0' && name[1] <= '7' && !name[2]) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
787 *out = context->aregs[name[1]-'0'];
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
788 } else if (!strcasecmp(name, "sr")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
789 *out = context->status << 8;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
790 for (int flag = 0; flag < 5; flag++) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
791 *out |= context->flags[flag] << (4-flag);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
792 }
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
793 } else if(!strcasecmp(name, "cycle")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
794 *out = context->current_cycle;
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
795 } else if (!strcasecmp(name, "pc")) {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
796 *out = root->address;
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
797 } else if (!strcasecmp(name, "usp")) {
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
798 *out = context->status & 0x20 ? context->aregs[8] : context->aregs[7];
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
799 } else if (!strcasecmp(name, "ssp")) {
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
800 *out = context->status & 0x20 ? context->aregs[7] : context->aregs[8];
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
801 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
802 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
803 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
804 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
805 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
806
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
807 static uint8_t set_m68k(debug_root *root, const char *name, uint32_t value)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
808 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
809 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
810 if ((name[0] == 'd' || name[0] == 'D') && name[1] >= '0' && name[1] <= '7' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
811 context->dregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
812 } else if ((name[0] == 'a' || name[0] == 'A') && name[1] >= '0' && name[1] <= '7' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
813 context->aregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
814 } else if (!strcasecmp(name, "sr")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
815 context->status = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
816 for (int flag = 0; flag < 5; flag++) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
817 context->flags[flag] = (value & (1 << (4 - flag))) != 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
818 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
819 } else if (!strcasecmp(name, "usp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
820 context->aregs[context->status & 0x20 ? 8 : 7] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
821 } else if (!strcasecmp(name, "ssp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
822 context->aregs[context->status & 0x20 ? 7 : 8] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
823 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
824 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
825 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
826 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
827 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
828
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
829 static uint8_t resolve_genesis(debug_root *root, const char *name, uint32_t *out)
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
830 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
831 if (resolve_m68k(root, name, out)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
832 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
833 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
834 m68k_context *m68k = root->cpu_context;
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
835 genesis_context *gen = m68k->system;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
836 if (!strcmp(name, "f") || !strcmp(name, "frame")) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
837 *out = gen->vdp->frame;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
838 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
839 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
840 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
841 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
842
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
843 void ambiguous_iter(char *key, tern_val val, uint8_t valtype, void *data)
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
844 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
845 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
846 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
847 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
848 free(full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
849 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
850
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
851 uint8_t parse_command(debug_root *root, char *text, parsed_command *out)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
852 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
853 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
854 while (*cur && *cur != '/' && !isspace(*cur))
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
855 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
856 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
857 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
858 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
859 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
860 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
861 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
862 tern_node *prefix_res = tern_find_prefix(root->commands, name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
863 command_def *def = tern_find_ptr(prefix_res, "");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
864 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
865 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
866 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
867 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
868 if (node->left || node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
869 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
870 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
871 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
872 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
873 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
874 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
875 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
876 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
877 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
878 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
879 fprintf(stderr, "%s is ambiguous. Matching commands:\n", name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
880 tern_foreach(prefix_res, ambiguous_iter, name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
881 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
882 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
883 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
884 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
885 fprintf(stderr, "%s is not a recognized command\n", name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
886 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
887 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
888 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
889 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
890 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
891 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
892 while (*cur && !isspace(*cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
893 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
894 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
895 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
896 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
897 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
898 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
899 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
900 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
901 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
902 if (*cur && *cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
903 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
904 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
905 text = cur;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
906 if (def->raw_args) {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
907 while (*cur && *cur != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
908 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
909 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
910 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
911 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
912 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
913 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
914 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
915 raw_param[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
916 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
917 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
918 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
919 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
920 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
921 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
922 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
923 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
924 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
925 arg_storage = def->min_args > 0 ? 2 * def->min_args : 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
926 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
927 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
928 args = calloc(arg_storage, sizeof(command_arg));
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
929 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
930 while (*text && *text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
931 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
932 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
933 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
934 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
935 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
936 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
937 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
938 fprintf(stderr, "Command %s takes a max of %d arguments, but at least %d provided\n", name, def->max_args, def->max_args+1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
939 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
940 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
941 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
942 args = realloc(args, arg_storage * sizeof(command_arg));
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
943 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
944 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
945 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
946 args[num_args].raw = malloc(after - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
947 memcpy(args[num_args].raw, text, after - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
948 args[num_args++].raw[after - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
949 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
950 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
951 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
952 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
953 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
954 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
955 fprintf(stderr, "Command %s requires at least %d arguments, but only %d provided\n", name, def->min_args, num_args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
956 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
957 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
958 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
959 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
960 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
961 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
962 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
963 out->format = format;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
964
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
965 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
966 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
967 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
968 for (int i = 0; i < num_args; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
969 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
970 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
971 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
972 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
973 free(args);
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
974 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
975 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
976 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
977 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
978 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
979
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
980 static void free_parsed_command(parsed_command *cmd);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
981 static void free_command_block(command_block *block)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
982 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
983 for (int i = 0; i < block->num_commands; i++)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
984 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
985 free_parsed_command(block->commands + i);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
986 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
987 free(block->commands);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
988 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
989
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
990 static void free_parsed_command(parsed_command *cmd)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
991 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
992 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
993 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
994 for (int i = 0; i < cmd->num_args; i++)
2173
894c7873a2b1 Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 2172
diff changeset
995 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
996 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
997 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
998 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
999 free_command_block(&cmd->block);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1000 free_command_block(&cmd->else_block);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1001 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1002 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1003
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1004 enum {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1005 READ_FAILED = 0,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1006 NORMAL,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1007 EMPTY,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1008 ELSE,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1009 END
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1010 };
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1011
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1012 static uint8_t read_parse_command(debug_root *root, parsed_command *out, int indent_level)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1013 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1014 ++indent_level;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1015 for (int i = 0; i < indent_level; i++)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1016 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1017 putchar('>');
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1018 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1019 putchar(' ');
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1020 fflush(stdout);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1021 #ifdef _WIN32
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1022 #define wait 0
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1023 #else
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1024 int wait = 1;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1025 fd_set read_fds;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1026 FD_ZERO(&read_fds);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1027 struct timeval timeout;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1028 #endif
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1029 do {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1030 process_events();
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1031 #ifndef _WIN32
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1032 timeout.tv_sec = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1033 timeout.tv_usec = 16667;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1034 FD_SET(fileno(stdin), &read_fds);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1035 if(select(fileno(stdin) + 1, &read_fds, NULL, NULL, &timeout) >= 1) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1036 wait = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1037 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1038 #endif
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1039 } while (wait);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1040
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1041 char input_buf[1024];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1042 if (!fgets(input_buf, sizeof(input_buf), stdin)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1043 fputs("fgets failed", stderr);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1044 return READ_FAILED;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1045 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1046 char *stripped = strip_ws(input_buf);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1047 if (!stripped[0]) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1048 return EMPTY;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1049 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1050 if (indent_level > 1) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1051 if (!strcmp(stripped, "else")) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1052 return ELSE;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1053 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1054 if (!strcmp(stripped, "end")) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1055 return END;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1056 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1057 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1058 if (parse_command(root, input_buf, out)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1059 if (!out->def->has_block) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1060 return NORMAL;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1061 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1062 int command_storage = 4;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1063 command_block *block = &out->block;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1064 block->commands = calloc(command_storage, sizeof(parsed_command));
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1065 block->num_commands = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1066 for (;;)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1067 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1068 if (block->num_commands == command_storage) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1069 command_storage *= 2;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1070 block->commands = realloc(block->commands, command_storage * sizeof(parsed_command));
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1071 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1072 switch (read_parse_command(root, block->commands + block->num_commands, indent_level))
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1073 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1074 case READ_FAILED:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1075 return READ_FAILED;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1076 case NORMAL:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1077 block->num_commands++;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1078 break;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1079 case END:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1080 return NORMAL;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1081 case ELSE:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1082 if (block == &out->else_block) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1083 fprintf(stderr, "Too many else blocks for command %s\n", out->def->names[0]);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1084 return READ_FAILED;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1085 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1086 if (!out->def->accepts_else) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1087 fprintf(stderr, "Command %s does not take an else block\n", out->def->names[0]);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1088 return READ_FAILED;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1089 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1090 block = &out->else_block;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1091 block->commands = calloc(command_storage, sizeof(parsed_command));
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1092 block->num_commands = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1093 break;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1094 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1095 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1096 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1097 return READ_FAILED;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1098 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1099
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1100 static uint8_t run_command(debug_root *root, parsed_command *cmd)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1101 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1102 if (!cmd->def->raw_args && !cmd->def->skip_eval) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1103 for (int i = 0; i < cmd->num_args; i++)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1104 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1105 if (!eval_expr(root, cmd->args[i].parsed, &cmd->args[i].value)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1106 fprintf(stderr, "Failed to eval %s\n", cmd->args[i].raw);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1107 return 1;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1108 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1109 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1110 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1111 return cmd->def->impl(root, cmd);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1112 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1113
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1114 static void debugger_repl(debug_root *root)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1115 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1116
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1117 int debugging = 1;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1118 parsed_command cmds[2] = {0};
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1119 int cur = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1120 uint8_t has_last = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1121 while(debugging) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1122 switch (read_parse_command(root, cmds + cur, 0))
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1123 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1124 case NORMAL:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1125 debugging = run_command(root, cmds + cur);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1126 if (debugging && has_last) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1127 cur = !cur;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1128 free_parsed_command(cmds + cur);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1129 memset(cmds + cur, 0, sizeof(cmds[cur]));
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1130 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1131 break;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1132 case EMPTY:
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1133 debugging = run_command(root, cmds + !cur);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1134 break;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1135 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1136 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1137 free_parsed_command(cmds);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1138 free_parsed_command(cmds + 1);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1139 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1140
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1141 static uint8_t cmd_quit(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1142 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1143 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1144 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1145
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1146 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1147 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1148 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1149 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1150
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1151 static void help_first_pass(char *key, tern_val val, uint8_t valtype, void *data)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1152 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1153 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1154 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1155 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1156 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1157 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1158 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1159 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1160 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1161 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1162 state->longest_command = len;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1163 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1164 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1165
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1166 static void help_reset_visited(char *key, tern_val val, uint8_t valtype, void *data)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1167 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1168 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1169 def->visited = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1170 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1171
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1172 static void help_second_pass(char *key, tern_val val, uint8_t valtype, void *data)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1173 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1174 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1175 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1176 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1177 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1178 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1179 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1180 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1181 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1182 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1183 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1184 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1185 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1186 int remaining = 80 - state->longest_command - 5;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1187 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1188 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1189 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1190 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1191 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1192 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1193 while (split_point > 0 && !isspace(def->desc[split_point]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1194 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1195 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1196 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1197 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1198 split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1199 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1200 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1201 extra_desc = def->desc + split_point + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1202 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1203 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1204 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1205 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1206 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1207 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1208 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1209 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1210 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1211 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1212 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1213 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1214 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1215 putchar(',');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1216 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1217 len += 2;
1312
9ab3f6781202 Allow adding .w or .b to select just the low word or byte of a register in a 68K debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 1311
diff changeset
1218 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1219 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1220 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1221 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1222 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1223 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1224 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1225 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1226 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1227 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1228 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1229 len++;
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
1230 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1231 fputs(extra_desc, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1232 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1233 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1234 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1235
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1236 static uint8_t cmd_help(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1237 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1238 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1239 tern_foreach(root->commands, help_first_pass, &state);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1240 tern_foreach(root->commands, help_reset_visited, &state);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1241 tern_foreach(root->commands, help_second_pass, &state);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1242 tern_foreach(root->commands, help_reset_visited, &state);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1243 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1244 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1245
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1246 static uint8_t cmd_continue(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1247 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1248 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1249 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1250
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1251 static void make_format_str(char *format_str, char *format)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1252 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1253 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1254 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1255 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1256 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1257 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1258 case 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1259 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1260 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1261 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1262 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1263 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1264 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1265 fprintf(stderr, "Unrecognized format character: %c\n", format[0]);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1266 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1267 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1268 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1269
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1270 static void do_print(debug_root *root, char *format_str, char *raw, uint32_t value)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1271 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1272 if (format_str[5] == 's') {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1273 char tmp[128];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1274 int j;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1275 uint32_t addr = value;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1276 for (j = 0; j < sizeof(tmp)-1; j++, addr++)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1277 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1278 uint32_t tmp_addr = addr;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1279 root->read_mem(root, &tmp_addr, 'b');
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1280 char c = tmp_addr;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1281 if (c < 0x20 || c > 0x7F) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1282 break;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1283 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1284 tmp[j] = c;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1285 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1286 tmp[j] = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1287 printf(format_str, raw, tmp);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1288 } else {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1289 printf(format_str, raw, value);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1290 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1291 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1292
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1293 static uint8_t cmd_print(debug_root *root, parsed_command *cmd)
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1294 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1295 char format_str[8];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1296 make_format_str(format_str, cmd->format);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1297 for (int i = 0; i < cmd->num_args; i++)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1298 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1299 do_print(root, format_str, cmd->args[i].raw, cmd->args[i].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1300 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1301 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1302 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1303
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1304 static uint8_t cmd_printf(debug_root *root, parsed_command *cmd)
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1305 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1306 char *param = cmd->raw;
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1307 if (!param) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1308 fputs("printf requires at least one parameter\n", stderr);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1309 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1310 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1311 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1312 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1313 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1314 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1315 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1316 fprintf(stderr, "First parameter to printf must be a string, found '%s'\n", param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1317 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1318 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1319 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1320 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1321 char *cur = param, *out = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1322 while (*cur && *cur != '"')
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1323 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1324 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1325 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1326 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1327 case 't':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1328 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1329 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1330 case 'n':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1331 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1332 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1333 case 'r':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1334 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1335 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1336 case '\\':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1337 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1338 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1339 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1340 fprintf(stderr, "Unsupported escape character %c in string %s\n", cur[1], fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1341 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1342 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1343 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1344 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1345 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1346 *(out++) = *(cur++);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1347 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1348 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1349 *out = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1350 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1351 param = cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1352 cur = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1353 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1354 while (*cur)
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1355 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1356 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1357 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1358 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1359 case 'x':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1360 case 'X':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1361 case 'c':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1362 case 'd':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1363 case 's':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1364 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1365 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1366 fprintf(stderr, "Unsupported format character %c\n", cur[1]);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1367 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1368 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1369 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1370 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1371 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1372 if (!arg) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1373 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1374 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1375 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1376 uint32_t val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1377 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1378 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1379 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1380 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1381 if (cur[1] == 's') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1382 char tmp[128];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1383 int j;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1384 for (j = 0; j < sizeof(tmp)-1; j++, val++)
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1385 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1386 uint32_t addr = val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1387 root->read_mem(root, &addr, 'b');
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1388 char c = addr;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1389 if (c < 0x20 || c > 0x7F) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1390 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1391 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1392 tmp[j] = c;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1393 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1394 tmp[j] = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1395 printf(format_str, tmp);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1396 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1397 printf(format_str, val);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1398 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1399 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1400 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1401 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1402 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1403 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1404 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1405 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1406 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1407
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1408 static uint8_t cmd_display(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1409 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1410 cmd_print(root, cmd);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1411 disp_def *ndisp = calloc(1, sizeof(*ndisp));
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1412 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1413 ndisp->index = root->disp_index++;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1414 ndisp->format = cmd->format ? strdup(cmd->format) : NULL;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1415 ndisp->num_args = cmd->num_args;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1416 ndisp->args = cmd->args;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1417 cmd->args = NULL;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1418 cmd->num_args = 0;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1419 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1420 printf("Added display %d\n", ndisp->index);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1421 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1422 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1423
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1424 static uint8_t cmd_delete_display(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1425 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1426 disp_def **cur = &root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1427 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1428 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1429 if ((*cur)->index == cmd->args[0].value) {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1430 disp_def *del_disp = *cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1431 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1432 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1433 for (int i = 0; i < del_disp->num_args; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1434 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1435 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1436 free_expr(del_disp->args[i].parsed);
2173
894c7873a2b1 Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 2172
diff changeset
1437 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1438 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1439 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1440 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1441 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1442 cur = &(*cur)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1443 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1444 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1445 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1446 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1447
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1448 static uint8_t cmd_softreset(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1449 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1450 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1451 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1452 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1453 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1454 fputs("Current system does not support soft reset", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1455 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1456 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1457 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1458
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1459 static uint8_t cmd_command(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1460 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1461 bp_def **target = find_breakpoint_idx(&root->breakpoints, cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1462 if (!target) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1463 fprintf(stderr, "Breakpoint %d does not exist!\n", cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1464 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1465 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1466 for (uint32_t i = 0; i < (*target)->num_commands; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1467 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1468 free_parsed_command((*target)->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1469 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1470 free((*target)->commands);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1471 (*target)->commands = cmd->block.commands;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1472 (*target)->num_commands = cmd->block.num_commands;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1473 cmd->block.commands = NULL;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1474 cmd->block.num_commands = 0;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1475 return 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1476 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1477
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1478 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1479 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1480 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1481 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1482 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1483 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1484 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1485 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1486
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1487 static uint8_t cmd_set(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1488 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1489 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1490 char size = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1491 uint32_t address;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1492 switch (cmd->args[0].parsed->type)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1493 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1494 case EXPR_SCALAR:
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1495 if (cmd->args[0].parsed->op.type == TOKEN_NAME) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1496 name = cmd->args[0].parsed->op.v.str;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1497 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1498 fputs("First argument to set must be a name or memory expression, not a number", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1499 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1500 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1501 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1502 case EXPR_SIZE:
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1503 size = cmd->args[0].parsed->op.v.op[0];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1504 if (cmd->args[0].parsed->left->op.type == TOKEN_NAME) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1505 name = cmd->args[0].parsed->left->op.v.str;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1506 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1507 fputs("First argument to set must be a name or memory expression, not a number", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1508 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1509 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1510 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1511 case EXPR_MEM:
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1512 size = cmd->args[0].parsed->op.v.op[0];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1513 if (!eval_expr(root, cmd->args[0].parsed->left, &address)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1514 fprintf(stderr, "Failed to eval %s\n", cmd->args[0].raw);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1515 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1516 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1517 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1518 default:
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1519 fprintf(stderr, "First argument to set must be a name or memory expression, got %s\n", expr_type_names[cmd->args[0].parsed->type]);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1520 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1521 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1522 if (!eval_expr(root, cmd->args[1].parsed, &cmd->args[1].value)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1523 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1524 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1525 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1526 uint32_t value = cmd->args[1].value;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1527 if (name && size && size != 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1528 uint32_t old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1529 if (!root->resolve(root, name, &old)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1530 fprintf(stderr, "Failed to eval %s\n", name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1531 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1532 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1533 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1534 old &= 0xFFFFFF00;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1535 value &= 0xFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1536 value |= old;
1314
ae932ca28282 Allow a .l suffix to a memory print command to allow fetching and printing a longword
Michael Pavone <pavone@retrodev.com>
parents: 1313
diff changeset
1537 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1538 old &= 0xFFFF0000;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1539 value &= 0xFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1540 value |= old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1541 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1542 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1543 if (name) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1544 if (!root->set(root, name, value)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1545 fprintf(stderr, "Failed to set %s\n", name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1546 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1547 } else if (!root->write_mem(root, address, value, size)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1548 fprintf(stderr, "Failed to write to address %X\n", address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1549 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1550 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1551 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1552
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1553 static uint8_t cmd_frames(debug_root *root, parsed_command *cmd)
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1554 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1555 current_system->enter_debugger_frames = cmd->args[0].value;
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1556 return 0;
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1557 }
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1558
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1559 static uint8_t cmd_bindup(debug_root *root, parsed_command *cmd)
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1560 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1561 if (!bind_up(cmd->raw)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1562 fprintf(stderr, "%s is not a valid binding name\n", cmd->raw);
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1563 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1564 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1565 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1566
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1567 static uint8_t cmd_binddown(debug_root *root, parsed_command *cmd)
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1568 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1569 if (!bind_down(cmd->raw)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1570 fprintf(stderr, "%s is not a valid binding name\n", cmd->raw);
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1571 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1572 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1573 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1574
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1575 static uint8_t cmd_condition(debug_root *root, parsed_command *cmd)
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1576 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1577 if (!eval_expr(root, cmd->args[0].parsed, &cmd->args[0].value)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1578 fprintf(stderr, "Failed to evaluate breakpoint number: %s\n", cmd->args[0].raw);
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1579 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1580 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1581 bp_def **target = find_breakpoint_idx(&root->breakpoints, cmd->args[0].value);
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1582 if (!*target) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1583 fprintf(stderr, "Failed to find breakpoint %u\n", cmd->args[0].value);
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1584 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1585 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1586 free_expr((*target)->condition);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1587 if (cmd->num_args > 1 && cmd->args[1].parsed) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1588 (*target)->condition = cmd->args[1].parsed;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1589 cmd->args[1].parsed = NULL;
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1590 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1591 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1592 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1593 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1594 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1595
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1596 static uint8_t cmd_delete_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1597 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1598 bp_def **this_bp = find_breakpoint_idx(&root->breakpoints, cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1599 if (!*this_bp) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1600 fprintf(stderr, "Breakpoint %d does not exist\n", cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1601 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1602 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1603 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1604 remove_breakpoint(root->cpu_context, tmp->address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1605 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1606 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1607 for (uint32_t i = 0; i < tmp->num_commands; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1608 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1609 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1610 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1611 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1612 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1613 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1614 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1615 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1616
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1617 static uint8_t cmd_breakpoint_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1618 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1619 insert_breakpoint(root->cpu_context, cmd->args[0].value, debugger);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1620 bp_def *new_bp = calloc(1, sizeof(bp_def));
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1621 new_bp->next = root->breakpoints;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1622 new_bp->address = cmd->args[0].value;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1623 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1624 root->breakpoints = new_bp;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1625 printf("68K Breakpoint %d set at %X\n", new_bp->index, cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1626 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1627 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1628
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1629 static uint8_t cmd_advance_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1630 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1631 insert_breakpoint(root->cpu_context, cmd->args[0].value, debugger);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1632 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1633 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1634
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1635 static uint8_t cmd_step_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1636 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1637 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1638 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1639 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1640 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1641 after = m68k_read_long(context->aregs[7], context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1642 } else if (inst->op == M68K_RTE || inst->op == M68K_RTR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1643 after = m68k_read_long(context->aregs[7] + 2, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1644 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1645 if (inst->op == M68K_BCC && inst->extra.cond != COND_TRUE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1646 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1647 root->branch_t = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1648 insert_breakpoint(context, root->branch_t, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1649 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1650 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1651 if (context->dregs[inst->dst.params.regs.pri] & 0xFFFF) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1652 after = m68k_branch_target(inst, context->dregs, context->aregs);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1653 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1654 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1655 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1656 root->branch_f = m68k_branch_target(inst, context->dregs, context->aregs);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1657 insert_breakpoint(context, root->branch_f, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1658 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1659 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1660 after = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
1314
ae932ca28282 Allow a .l suffix to a memory print command to allow fetching and printing a longword
Michael Pavone <pavone@retrodev.com>
parents: 1313
diff changeset
1661 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1662 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1663 insert_breakpoint(root->cpu_context, after, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1664 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1665 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1666
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1667 static uint8_t cmd_over_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1668 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1669 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1670 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1671 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1672 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1673 after = m68k_read_long(context->aregs[7], context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1674 } else if (inst->op == M68K_RTE || inst->op == M68K_RTR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1675 after = m68k_read_long(context->aregs[7] + 2, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1676 } else if(m68k_is_noncall_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1677 if (inst->op == M68K_BCC && inst->extra.cond != COND_TRUE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1678 root->branch_t = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1679 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1680 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1681 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1682 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1683 insert_breakpoint(context, root->branch_t, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1684 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1685 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1686 uint32_t target = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1687 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1688 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1689 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1690 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1691 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1692 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1693 insert_breakpoint(context, root->branch_f, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1694 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1695 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1696 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1697 after = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1698 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1699 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1700 insert_breakpoint(root->cpu_context, after, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1701 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1702 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1703
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1704 static uint8_t cmd_next_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1705 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1706 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1707 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1708 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1709 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1710 after = m68k_read_long(context->aregs[7], context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1711 } else if (inst->op == M68K_RTE || inst->op == M68K_RTR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1712 after = m68k_read_long(context->aregs[7] + 2, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1713 } else if(m68k_is_noncall_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1714 if (inst->op == M68K_BCC && inst->extra.cond != COND_TRUE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1715 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1716 root->branch_t = m68k_branch_target(inst, context->dregs, context->aregs);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1717 insert_breakpoint(context, root->branch_t, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1718 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1719 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1720 if (context->dregs[inst->dst.params.regs.pri] & 0xFFFF) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1721 after = m68k_branch_target(inst, context->dregs, context->aregs);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1722 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1723 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1724 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1725 root->branch_f = m68k_branch_target(inst, context->dregs, context->aregs);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1726 insert_breakpoint(context, root->branch_f, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1727 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1728 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1729 after = m68k_branch_target(inst, context->dregs, context->aregs) & 0xFFFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1730 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1731 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1732 insert_breakpoint(root->cpu_context, after, debugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1733 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1734 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1735
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1736 static uint8_t cmd_backtrace_m68k(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1737 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1738 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1739 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1740 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1741 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1742 uint32_t bt_address = m68k_instruction_fetch(stack, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1743 bt_address = get_instruction_start(context->options, bt_address - 2);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1744 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1745 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1746 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1747 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1748 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1749 m68k_decode(m68k_instruction_fetch, context, &inst, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1750 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1751 printf("%X: %s\n", bt_address, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1752 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1753 //non-return address value on stack can be word wide
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1754 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1755 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1756 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1757 //TODO: Make sure we don't wander into an invalid memory region
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1758 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1759 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1760 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1761
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1762 static uint8_t cmd_vdp_sprites(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1763 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1764 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1765 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1766 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1767 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1768 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1769
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1770 static uint8_t cmd_vdp_regs(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1771 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1772 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1773 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1774 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1775 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1776 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1777
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1778 static uint8_t cmd_ym_channel(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1779 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1780 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1781 genesis_context * gen = context->system;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1782 if (cmd->num_args) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1783 ym_print_channel_info(gen->ym, cmd->args[0].value - 1);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1784 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1785 for (int i = 0; i < 6; i++) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1786 ym_print_channel_info(gen->ym, i);
1314
ae932ca28282 Allow a .l suffix to a memory print command to allow fetching and printing a longword
Michael Pavone <pavone@retrodev.com>
parents: 1313
diff changeset
1787 }
2173
894c7873a2b1 Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 2172
diff changeset
1788 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1789 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1790 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1791
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1792 static uint8_t cmd_ym_timer(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1793 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1794 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1795 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1796 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1797 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1798 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1799
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1800 static uint8_t cmd_sub(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1801 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1802 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1803 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1804 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1805 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1806 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1807 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1808 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1809 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1810 if (param && *param && !isspace(*param)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1811 parsed_command cmd;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1812 debug_root *sub_root = find_m68k_root(cd->m68k);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1813 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1814 fputs("Failed to get debug root for Sub CPU\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1815 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1816 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1817 if (!parse_command(sub_root, param, &cmd)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1818 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1819 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1820 uint8_t ret = run_command(sub_root, &cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1821 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1822 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1823 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1824 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1825 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1826 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1827 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1828
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1829 static uint8_t cmd_main(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1830 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1831 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1832 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1833 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1834 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1835 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1836 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1837 segacd_context *cd = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
1838
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1839 if (param && *param && !isspace(*param)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1840 parsed_command cmd;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1841 debug_root *main_root = find_m68k_root(cd->genesis->m68k);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1842 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1843 fputs("Failed to get debug root for Main CPU\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1844 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1845 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1846 if (!parse_command(main_root, param, &cmd)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1847 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1848 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1849 uint8_t ret = run_command(main_root, &cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1850 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1851 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1852 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1853 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1854 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1855 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1856 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1857
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1858 static uint8_t cmd_gen_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1859 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1860 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1861 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1862 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1863 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1864 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1865 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1866 genesis_context *gen = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
1867
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1868 if (param && *param && !isspace(*param)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1869 parsed_command cmd;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1870 debug_root *z80_root = find_z80_root(gen->z80);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1871 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1872 fputs("Failed to get debug root for Z80\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1873 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1874 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1875 if (!parse_command(z80_root, param, &cmd)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1876 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1877 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1878 uint8_t ret = run_command(z80_root, &cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1879 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1880 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1881 } else {
2184
408fb8a7e990 Implement argumentless variant of z80 debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2183
diff changeset
1882 gen->enter_z80_debugger = 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1883 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1884 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1885 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1886
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1887 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1888 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1889 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1890 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1891 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1892 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1893 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1894 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1895 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1896 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1897 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1898 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1899 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1900 "help", "?", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1901 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1902 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1903 .desc = "Print a list of available commands for the current debug context",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1904 .impl = cmd_help,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1905 .min_args = 0,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1906 .max_args = 1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1907 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1908 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1909 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1910 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1911 "continue", "c", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1912 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1913 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1914 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1915 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1916 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1917 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1918 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1919 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1920 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1921 "print", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1922 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1923 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1924 .desc = "Print one or more expressions using the optional format character",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1925 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1926 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1927 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1928 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1929 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1930 .names = (const char *[]){
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1931 "printf", NULL
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1932 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1933 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1934 .desc = "Print a string with C-style formatting specifiers replaced with the value of the remaining arguments",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1935 .impl = cmd_printf,
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1936 .min_args = 1,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1937 .max_args = -1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1938 .raw_args = 1
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1939 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1940 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1941 .names = (const char *[]){
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1942 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1943 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1944 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1945 .desc = "Perform a soft-reset for the current system",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1946 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1947 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1948 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1949 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1950 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1951 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1952 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1953 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1954 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1955 .desc = "Print one or more expressions every time the debugger is entered",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1956 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1957 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1958 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1959 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1960 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1961 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1962 "deletedisplay", "dd", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1963 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1964 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1965 .desc = "Remove expressions added with the `display` command",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1966 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1967 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1968 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1969 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1970 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1971 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1972 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1973 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1974 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1975 .desc = "Set a list of debugger commands to be executed when the given breakpoint is hit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1976 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1977 .min_args = 1,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1978 .max_args = 1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1979 .has_block = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1980 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1981 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1982 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1983 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1984 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1985 .usage = "set MEM|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1986 .desc = "Set a register, symbol or memory location to the result of evaluating VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1987 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1988 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1989 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1990 .skip_eval = 1
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1991 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1992 {
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1993 .names = (const char *[]){
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1994 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1995 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1996 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1997 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1998 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1999 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2000 .max_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2001 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2002 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2003 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2004 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2005 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2006 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2007 .desc = "Simulate a keyup for binding NAME",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2008 .impl = cmd_bindup,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2009 .min_args = 1,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2010 .max_args = 1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2011 .raw_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2012 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2013 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2014 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2015 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2016 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2017 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2018 .desc = "Simulate a keydown for binding NAME",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2019 .impl = cmd_binddown,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2020 .min_args = 1,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2021 .max_args = 1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2022 .raw_args = 1
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2023 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2024 {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2025 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2026 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2027 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2028 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2029 .desc = "Makes breakpoint BREAKPOINT conditional on the value of EXPRESSION or removes a condition if EXPRESSION is omitted",
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2030 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2031 .min_args = 1,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2032 .max_args = 2,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2033 .skip_eval = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2034 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2035 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2036 #define NUM_COMMON (sizeof(common_commands)/sizeof(*common_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2037
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2038 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2039 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2040 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2041 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2042 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2043 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2044 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2045 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2046 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2047 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2048 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2049 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2050 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2051 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2052 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2053 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2054 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2055 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2056 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2057 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2058 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2059 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2060 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2061 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2062 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2063 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2064 .desc = "Advance to the next instruction, stepping into subroutines",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2065 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2066 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2067 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2068 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2069 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2070 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2071 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2072 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2073 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2074 .desc = "Advance to the next instruction, ignoring branches to lower addresses",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2075 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2076 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2077 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2078 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2079 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2080 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2081 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2082 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2083 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2084 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2085 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2086 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2087 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2088 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2089 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2090 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2091 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2092 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2093 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2094 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2095 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2096 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2097 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2098 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2099 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2100 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2101 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2102 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2103 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2104 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2105 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2106 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2107 .max_args = 1
2112
3abb64bd0da6 Add support for printing strings in 68K debugger
Michael Pavone <pavone@retrodev.com>
parents: 2107
diff changeset
2108 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2109 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2110
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2111 #define NUM_68K (sizeof(m68k_commands)/sizeof(*m68k_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2112
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2113 command_def genesis_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2114 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2115 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2116 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2117 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2118 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2119 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2120 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2121 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2122 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2123 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2124 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2125 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2126 "vdpsregs", "vr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2127 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2128 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2129 .desc = "Print VDP register values with a short description",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2130 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2131 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2132 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2133 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2134 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2135 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2136 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2137 "z80", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2138 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2139 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2140 .desc = "Run a Z80 debugger command or switch to Z80 context when no command is given",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2141 .impl = cmd_gen_z80,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2142 .min_args = 0,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2143 .max_args = -1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2144 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2145 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2146 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2147 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2148 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2149 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2150 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2151 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2152 .desc = "Print YM-2612 channel and operator params. Limited to CHANNEL if specified",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2153 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2154 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2155 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2156 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2157 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2158 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2159 "ymtimer", "yt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2160 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2161 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2162 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2163 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2164 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2165 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2166 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2167 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2168
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2169 #define NUM_GENESIS (sizeof(genesis_commands)/sizeof(*genesis_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2170
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2171 command_def scd_main_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2172 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2173 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2174 "subcpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2175 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2176 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2177 .desc = "Run a Sub-CPU debugger command or switch to Sub-CPU context when no command is given",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2178 .impl = cmd_sub,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2179 .min_args = 0,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2180 .max_args = -1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2181 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2182 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2183 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2184
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2185 #define NUM_SCD_MAIN (sizeof(scd_main_commands)/sizeof(*scd_main_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2186
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2187 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2188 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2189 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2190 "maincpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2191 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2192 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2193 .desc = "Run a Main-CPU debugger command or switch to Main-CPU context when no command is given",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2194 .impl = cmd_main,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2195 .min_args = 0,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2196 .max_args = -1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2197 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2198 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2199 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2200
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2201 #define NUM_SCD_SUB (sizeof(scd_main_commands)/sizeof(*scd_main_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2202
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2203 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2204
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2205 static uint8_t cmd_delete_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2206 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2207 bp_def **this_bp = find_breakpoint_idx(&root->breakpoints, cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2208 if (!*this_bp) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2209 fprintf(stderr, "Breakpoint %d does not exist\n", cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2210 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2211 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2212 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2213 zremove_breakpoint(root->cpu_context, tmp->address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2214 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2215 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2216 for (uint32_t i = 0; i < tmp->num_commands; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2217 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2218 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2219 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2220 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2221 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2222 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2223 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2224 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2225
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2226 static uint8_t cmd_breakpoint_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2227 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2228 zinsert_breakpoint(root->cpu_context, cmd->args[0].value, (uint8_t *)zdebugger);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2229 bp_def *new_bp = calloc(1, sizeof(bp_def));
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2230 new_bp->next = root->breakpoints;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2231 new_bp->address = cmd->args[0].value;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2232 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2233 root->breakpoints = new_bp;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2234 printf("Z80 Breakpoint %d set at %X\n", new_bp->index, cmd->args[0].value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2235 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2236 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2237
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2238 static uint8_t cmd_advance_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2239 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2240 zinsert_breakpoint(root->cpu_context, cmd->args[0].value, (uint8_t *)zdebugger);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2241 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2242 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2243
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2244 static uint8_t cmd_step_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2245 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2246 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2247 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2248 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2249 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2250 if (inst->op == Z80_JP || inst->op == Z80_CALL || inst->op == Z80_RST) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2251 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2252 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2253 } else if (inst->ea_reg == Z80_HL) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2254 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2255 after = context->regs[Z80_H] << 8 | context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2256 } else if (inst->ea_reg == Z80_IX) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2257 after = context->regs[Z80_IXH] << 8 | context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2258 } else if (inst->ea_reg == Z80_IY) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2259 after = context->regs[Z80_IYH] << 8 | context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2260 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2261 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2262 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2263 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2264 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2265 uint8_t *sp = get_native_pointer(context->sp, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2266 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2267 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2268 sp = get_native_pointer((context->sp + 1) & 0xFFFF, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2269 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2270 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2271 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2272 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2273 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2274 zinsert_breakpoint(context, after, (uint8_t *)zdebugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2275 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2276 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2277
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2278 static uint8_t cmd_over_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2279 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2280 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2281 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2282 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2283
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2284 static uint8_t cmd_next_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2285 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2286 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2287 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2288 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2289 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2290 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2291 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2292 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2293 } else if (inst->ea_reg == Z80_HL) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2294 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2295 after = context->regs[Z80_H] << 8 | context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2296 } else if (inst->ea_reg == Z80_IX) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2297 after = context->regs[Z80_IXH] << 8 | context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2298 } else if (inst->ea_reg == Z80_IY) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2299 after = context->regs[Z80_IYH] << 8 | context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2300 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2301 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2302 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2303 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2304 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2305 uint8_t *sp = get_native_pointer(context->sp, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2306 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2307 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2308 sp = get_native_pointer((context->sp + 1) & 0xFFFF, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2309 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2310 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2311 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2312 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2313 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2314 zinsert_breakpoint(context, after, (uint8_t *)zdebugger);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2315 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2316 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2317
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2318 static uint8_t cmd_backtrace_z80(debug_root *root, parsed_command *cmd)
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2319 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2320 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2321 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2322 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2323 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2324 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2325 if (!root->read_mem(root, &bt_address, 'w')) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2326 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2327 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2328 bt_address = z80_get_instruction_start(context, bt_address - 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2329 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2330 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2331 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2332 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2333 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2334 uint8_t *pc = get_native_pointer(bt_address, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2335 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2336 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2337 printf("%X: %s\n", bt_address, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2338 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2339 //non-return address value on stack can be byte wide
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2340 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2341 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2342 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2343 //TODO: Make sure we don't wander into an invalid memory region
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2344 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2345 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2346 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2347
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2348 static uint8_t cmd_gen_m68k(debug_root *root, parsed_command *cmd)
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2349 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2350 char *param = cmd->raw;
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2351 while (param && *param && isblank(*param))
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2352 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2353 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2354 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2355 genesis_context *gen = (genesis_context *)current_system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2356
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2357 if (param && *param && !isspace(*param)) {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2358 parsed_command cmd;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2359 debug_root *m68k_root = find_m68k_root(gen->m68k);
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2360 if (!m68k_root) {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2361 fputs("Failed to get debug root for M68K\n", stderr);
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2362 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2363 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2364 if (!parse_command(m68k_root, param, &cmd)) {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2365 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2366 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2367 uint8_t ret = run_command(m68k_root, &cmd);
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2368 free_parsed_command(&cmd);
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2369 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2370 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2371 gen->header.enter_debugger = 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2372 return 0;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2373 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2374 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2375
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2376 command_def z80_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2377 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2378 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2379 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2380 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2381 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2382 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2383 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2384 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2385 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2386 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2387 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2388 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2389 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2390 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2391 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2392 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2393 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2394 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2395 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2396 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2397 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2398 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2399 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2400 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2401 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2402 .desc = "Advance to the next instruction, stepping into subroutines",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2403 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2404 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2405 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2406 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2407 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2408 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2409 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2410 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2411 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2412 .desc = "Advance to the next instruction, ignoring branches to lower addresses",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2413 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2414 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2415 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2416 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2417 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2418 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2419 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2420 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2421 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2422 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2423 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2424 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2425 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2426 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2427 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2428 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2429 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2430 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2431 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2432 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2433 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2434 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2435 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2436 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2437 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2438 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2439 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2440 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2441 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2442 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2443 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2444 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2445 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2446 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2447 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2448
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2449 #define NUM_Z80 (sizeof(z80_commands)/sizeof(*z80_commands))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2450
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2451 command_def gen_z80_commands[] = {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2452 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2453 .names = (const char *[]){
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2454 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2455 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2456 .usage = "m68k [COMMAND]",
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2457 .desc = "Run a M68K debugger command or switch to M68K context when no command is given",
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2458 .impl = cmd_gen_m68k,
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2459 .min_args = 0,
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2460 .max_args = -1,
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
2461 .raw_args = 1
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2462 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2463 };
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2464
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2465 #define NUM_GEN_Z80 (sizeof(gen_z80_commands)/sizeof(*gen_z80_commands))
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2466
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2467 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2468
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2469 void add_commands(debug_root *root, command_def *defs, uint32_t num_commands)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2470 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2471 for (uint32_t i = 0; i < num_commands; i++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2472 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2473 for (int j = 0; defs[i].names[j]; j++)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2474 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2475 root->commands = tern_insert_ptr(root->commands, defs[i].names[j], defs + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2476 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2477 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2478 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2479
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2480 debug_root *find_m68k_root(m68k_context *context)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2481 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2482 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2483 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2484 add_commands(root, common_commands, NUM_COMMON);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2485 add_commands(root, m68k_commands, NUM_68K);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2486 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2487 root->write_mem = write_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2488 root->set = set_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2489 switch (current_system->type)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2490 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2491 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2492 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2493 //check if this is the main CPU
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2494 if (context->system == current_system) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2495 root->resolve = resolve_genesis;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2496 add_commands(root, genesis_commands, NUM_GENESIS);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2497 if (current_system->type == SYSTEM_SEGACD) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2498 add_commands(root, scd_main_commands, NUM_SCD_MAIN);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2499 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2500 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2501 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2502 add_commands(root, scd_sub_commands, NUM_SCD_SUB);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2503 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2504 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2505 root->resolve = resolve_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2506 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2507 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2508 return root;
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
2509 }
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
2510
565
9324f721efa6 Add a separate flag/define for disabling the Z80 at compile time to ease refactoring
Michael Pavone <pavone@retrodev.com>
parents: 548
diff changeset
2511 #ifndef NO_Z80
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
2512
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2513 static uint8_t read_z80(debug_root *root, uint32_t *out, char size)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2514 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2515 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2516 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2517 *out = read_byte(address, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2518 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2519 *out |= read_byte(address + 1, (void **)context->mem_pointers, &context->options->gen, context) << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2520 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2521 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2522 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2523
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2524 static uint8_t write_z80(debug_root *root, uint32_t address, uint32_t value, char size)
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2525 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2526 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2527 write_byte(address, value, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2528 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2529 write_byte(address + 1, value >> 8, (void **)context->mem_pointers, &context->options->gen, context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2530 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2531 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2532 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2533
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2534 static uint8_t resolve_z80(debug_root *root, const char *name, uint32_t *out)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2535 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2536 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2537 switch (tolower(name[0]))
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2538 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2539 case 'a':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2540 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2541 *out = context->regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2542 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2543 *out = context->alt_regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2544 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2545 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2546 *out = context->regs[Z80_A] << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2547 *out |= context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2548 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2549 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2550 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2551 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2552 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2553 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2554 *out = context->alt_regs[Z80_A] << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2555 *out |= context->alt_flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2556 *out |= context->alt_flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2557 *out |= context->alt_flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2558 *out |= context->alt_flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2559 *out |= context->alt_flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2560 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2561 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2562 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2563 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2564 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2565 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2566 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2567 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2568 case 'b':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2569 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2570 *out = context->regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2571 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2572 *out = context->alt_regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2573 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2574 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2575 *out = context->regs[Z80_B] << 8 | context->regs[Z80_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2576 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2577 *out = context->alt_regs[Z80_B] << 8 | context->alt_regs[Z80_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2578 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2579 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2580 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2581 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2582 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2583 case 'c':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2584 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2585 *out = context->regs[Z80_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2586 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2587 *out = context->alt_regs[Z80_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2588 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2589 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2590 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2591 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2592 case 'd':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2593 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2594 *out = context->regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2595 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2596 *out = context->alt_regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2597 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2598 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2599 *out = context->regs[Z80_D] << 8 | context->regs[Z80_E];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2600 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2601 *out = context->alt_regs[Z80_D] << 8 | context->alt_regs[Z80_E];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2602 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2603 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2604 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2605 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2606 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2607 case 'e':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2608 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2609 *out = context->regs[Z80_E];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2610 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2611 *out = context->alt_regs[Z80_E];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2612 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2613 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2614 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2615 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2616 case 'f':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2617 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2618 *out = context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2619 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2620 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2621 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2622 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2623 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2624 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2625 *out = context->alt_flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2626 *out |= context->alt_flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2627 *out |= context->alt_flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2628 *out |= context->alt_flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2629 *out |= context->alt_flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2630 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2631 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2632 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2633 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2634 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2635 case 'h':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2636 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2637 *out = context->regs[Z80_H];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2638 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2639 *out = context->alt_regs[Z80_H];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2640 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2641 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2642 *out = context->regs[Z80_H] << 8 | context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2643 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2644 *out = context->alt_regs[Z80_H] << 8 | context->alt_regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2645 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2646 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2647 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2648 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2649 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2650 case 'i':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2651 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2652 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2653 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2654 *out = context->regs[Z80_I];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2655 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2656 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2657 if (name[2] != 'f' || name[3] < '1' || name[4]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2658 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2659 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2660 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2661 *out = context->iff1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2662 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2663 *out = context->iff2;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2664 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2665 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2666 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2667 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2668 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2669 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2670 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2671 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2672 *out = context->im;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2673 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2674 case 'n':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2675 if (strcasecmp(name +2, "t_cycle")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2676 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2677 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2678 *out = context->int_cycle;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2679 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2680 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2681 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2682 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2683 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2684 *out = context->regs[Z80_I] << 8 | context->regs[Z80_R];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2685 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2686 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2687 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2688 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2689 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2690 *out = context->regs[Z80_IXH] << 8 | context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2691 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2692 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2693 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2694 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2695 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2696 *out = context->regs[Z80_IXH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2697 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2698 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2699 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2700 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2701 *out = context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2702 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2703 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2704 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2705 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2706 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2707 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2708 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2709 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2710 *out = context->regs[Z80_IYH] << 8 | context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2711 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2712 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2713 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2714 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2715 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2716 *out = context->regs[Z80_IYH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2717 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2718 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2719 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2720 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2721 *out = context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2722 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2723 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2724 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2725 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2726 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2727 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2728 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2729 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2730 case 'l':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2731 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2732 *out = context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2733 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2734 *out = context->alt_regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2735 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2736 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2737 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2738 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2739 case 'p':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2740 if (tolower(name[1]) != 'c' || name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2741 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2742 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2743 *out = root->address;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2744 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2745 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2746 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2747 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2748 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2749 *out = context->regs[Z80_R];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2750 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2751 if (tolower(name[1]) != 'p' || name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2752 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2753 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2754 *out = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2755 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2756 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2757 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2758 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2759 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2760 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2761
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2762 static uint8_t set_z80(debug_root *root, const char *name, uint32_t value)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2763 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2764 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2765 switch (tolower(name[0]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2766 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2767 case 'a':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2768 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2769 context->regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2770 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2771 context->alt_regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2772 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2773 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2774 context->regs[Z80_A] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2775 context->flags[ZF_S] = value >> 7 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2776 context->flags[ZF_Z] = value >> 6 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2777 context->flags[ZF_H] = value >> 4 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2778 context->flags[ZF_PV] = value >> 2 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2779 context->flags[ZF_N] = value >> 1 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2780 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2781 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2782 context->alt_regs[Z80_A] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2783 context->alt_flags[ZF_S] = value >> 7 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2784 context->alt_flags[ZF_Z] = value >> 6 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2785 context->alt_flags[ZF_H] = value >> 4 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2786 context->alt_flags[ZF_PV] = value >> 2 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2787 context->alt_flags[ZF_N] = value >> 1 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2788 context->alt_flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2789 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2790 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2791 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2792 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2793 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2794 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2795 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2796 case 'b':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2797 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2798 context->regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2799 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2800 context->alt_regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2801 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2802 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2803 context->regs[Z80_B] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2804 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2805 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2806 context->alt_regs[Z80_B] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2807 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2808 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2809 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2810 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2811 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2812 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2813 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2814 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2815 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2816 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2817 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2818 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2819 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2820 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2821 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2822 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2823 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2824 context->regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2825 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2826 context->alt_regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2827 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2828 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2829 context->regs[Z80_D] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2830 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2831 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2832 context->alt_regs[Z80_D] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2833 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2834 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2835 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2836 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2837 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2838 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2839 case 'e':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2840 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2841 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2842 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2843 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2844 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2845 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2846 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2847 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2848 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2849 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2850 context->flags[ZF_S] = value >> 7 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2851 context->flags[ZF_Z] = value >> 6 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2852 context->flags[ZF_H] = value >> 4 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2853 context->flags[ZF_PV] = value >> 2 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2854 context->flags[ZF_N] = value >> 1 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2855 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2856 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2857 context->alt_flags[ZF_S] = value >> 7 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2858 context->alt_flags[ZF_Z] = value >> 6 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2859 context->alt_flags[ZF_H] = value >> 4 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2860 context->alt_flags[ZF_PV] = value >> 2 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2861 context->alt_flags[ZF_N] = value >> 1 & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2862 context->alt_flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2863 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2864 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2865 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2866 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2867 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2868 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2869 context->regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2870 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2871 context->alt_regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2872 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2873 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2874 context->regs[Z80_H] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2875 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2876 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2877 context->alt_regs[Z80_H] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2878 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2879 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2880 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2881 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2882 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2883 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2884 case 'i':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2885 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2886 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2887 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2888 context->regs[Z80_I] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2889 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2890 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2891 if (name[2] != 'f' || name[3] < '1' || name[4]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2892 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2893 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2894 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2895 context->iff1 = value != 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2896 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2897 context->iff2 = value != 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2898 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2899 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2900 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2901 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2902 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2903 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2904 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2905 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2906 context->im = value & 3;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2907 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2908 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2909 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2910 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2911 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2912 context->regs[Z80_I] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2913 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2914 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2915 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2916 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2917 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2918 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2919 context->regs[Z80_IXH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2920 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2921 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2922 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2923 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2924 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2925 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2926 context->regs[Z80_IXH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2927 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2928 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2929 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2930 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2931 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2932 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2933 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2934 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2935 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2936 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2937 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2938 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2939 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2940 context->regs[Z80_IYH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2941 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2942 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2943 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2944 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2945 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2946 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2947 context->regs[Z80_IYH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2948 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2949 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2950 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2951 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2952 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2953 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2954 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2955 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2956 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2957 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2958 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2959 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2960 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2961 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2962 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2963 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2964 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2965 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2966 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2967 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2968 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2969 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2970 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2971 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2972 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2973 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2974 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2975 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2976 if (tolower(name[1]) != 'p' || name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2977 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2978 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2979 context->sp = value;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2980 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2981 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2982 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2983 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2984 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2985 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2986
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2987 debug_root *find_z80_root(z80_context *context)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2988 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2989 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2990 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2991 add_commands(root, common_commands, NUM_COMMON);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2992 add_commands(root, z80_commands, NUM_Z80);
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2993 if (current_system->type == SYSTEM_GENESIS || current_system->type == SYSTEM_SEGACD) {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2994 add_commands(root, gen_z80_commands, NUM_GEN_Z80);
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2995 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2996 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2997 root->write_mem = write_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2998 root->set = set_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2999 root->resolve = resolve_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3000 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3001 return root;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3002 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3003
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3004 z80_context * zdebugger(z80_context * context, uint16_t address)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3005 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3006 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3007 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3008 z80inst inst;
1103
22e87b739ad6 WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents: 985
diff changeset
3009 genesis_context *system = context->system;
794
792be135d3af Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents: 792
diff changeset
3010 init_terminal();
2180
b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor
Michael Pavone <pavone@retrodev.com>
parents: 2179
diff changeset
3011 debug_root *root = find_z80_root(context);
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3012 if (!root) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3013 return context;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3014 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3015 root->address = address;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3016 //Check if this is a user set breakpoint, or just a temporary one
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3017 bp_def ** this_bp = find_breakpoint(&root->breakpoints, address);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3018 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3019 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3020 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3021 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3022 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3023 return context;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3024 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3025 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3026 fprintf(stderr, "Failed to eval condition for Z80 breakpoint %u\n", (*this_bp)->index);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3027 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3028 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3029 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3030 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3031 printf("Z80 Breakpoint %d hit\n", (*this_bp)->index);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3032 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3033 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3034 }
1752
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable
Michael Pavone <pavone@retrodev.com>
parents: 1630
diff changeset
3035 uint8_t * pc = get_native_pointer(address, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
1129
6b5c92b6205c Enabled Z80 debugger in PBC mode
Michael Pavone <pavone@retrodev.com>
parents: 1111
diff changeset
3036 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode
Michael Pavone <pavone@retrodev.com>
parents: 1111
diff changeset
3037 fatal_error("Failed to get native pointer on entering Z80 debugger at address %X\n", address);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3038 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3039 uint8_t * after_pc = z80_decode(pc, &inst);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3040 uint16_t after = address + (after_pc-pc);
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3041 root->after = after;
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3042 root->inst = &inst;
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3043 for (disp_def * cur = root->displays; cur; cur = cur->next) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3044 char format_str[8];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3045 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3046 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3047 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3048 eval_expr(root, cur->args[i].parsed, &cur->args[i].value);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3049 do_print(root, format_str, cur->args[i].raw, cur->args[i].value);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3050 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3051 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3052
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3053 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3054 printf("%X:\t%s\n", address, input_buf);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3055 debugger_repl(root);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3056 return context;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3057 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3058
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3059 #endif
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3060
1329
85a90964b557 Fix interaction between 68K debugger and instruction retranslation due to self modifying code or bank switching
Michael Pavone <pavone@retrodev.com>
parents: 1314
diff changeset
3061 void debugger(m68k_context * context, uint32_t address)
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3062 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3063 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3064 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3065 m68kinst inst;
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3066
794
792be135d3af Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents: 792
diff changeset
3067 init_terminal();
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3068
2054
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM
Michael Pavone <pavone@retrodev.com>
parents: 1965
diff changeset
3069 context->options->sync_components(context, 0);
2104
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3070 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3071 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3072 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3073 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3074 debug_root *root = find_m68k_root(context);
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3075 if (!root) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3076 return;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3077 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3078 //probably not necessary, but let's play it safe
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3079 address &= 0xFFFFFF;
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3080 if (address == root->branch_t) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3081 bp_def ** f_bp = find_breakpoint(&root->breakpoints, root->branch_f);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3082 if (!*f_bp) {
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3083 remove_breakpoint(context, root->branch_f);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3084 }
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3085 root->branch_t = root->branch_f = 0;
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3086 } else if(address == root->branch_f) {
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3087 bp_def ** t_bp = find_breakpoint(&root->breakpoints, root->branch_t);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3088 if (!*t_bp) {
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3089 remove_breakpoint(context, root->branch_t);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3090 }
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3091 root->branch_t = root->branch_f = 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3092 }
849
1416c4261d5b Fix some debug commands that got broken when I added support for the command command
Michael Pavone <pavone@retrodev.com>
parents: 831
diff changeset
3093
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3094 root->address = address;
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3095 int debugging = 1;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3096 //Check if this is a user set breakpoint, or just a temporary one
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3097 bp_def ** this_bp = find_breakpoint(&root->breakpoints, address);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3098 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3099 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3100 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3101 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3102 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3103 return;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3104 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3105 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3106 fprintf(stderr, "Failed to eval condition for M68K breakpoint %u\n", (*this_bp)->index);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3107 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3108 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3109 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3110 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3111 for (uint32_t i = 0; debugging && i < (*this_bp)->num_commands; i++)
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3112 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3113 debugging = run_command(root, (*this_bp)->commands + i);
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3114 }
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3115 if (debugging) {
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3116 printf("68K Breakpoint %d hit\n", (*this_bp)->index);
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3117 } else {
1329
85a90964b557 Fix interaction between 68K debugger and instruction retranslation due to self modifying code or bank switching
Michael Pavone <pavone@retrodev.com>
parents: 1314
diff changeset
3118 return;
830
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3119 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3120 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3121 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3122 }
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3123 uint32_t after = m68k_decode(m68k_instruction_fetch, context, &inst, address);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3124 root->after = after;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3125 root->inst = &inst;
2107
f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2104
diff changeset
3126 for (disp_def * cur = root->displays; cur; cur = cur->next) {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3127 char format_str[8];
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3128 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3129 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3130 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3131 eval_expr(root, cur->args[i].parsed, &cur->args[i].value);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3132 do_print(root, format_str, cur->args[i].raw, cur->args[i].value);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3133 }
829
cc05444a4a4e WIP debugger improvements. Partial support for display command in 68K debugger. Minor refactor to support commands on a breakpoint.
Michael Pavone <pavone@retrodev.com>
parents: 794
diff changeset
3134 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3135 m68k_disasm(&inst, input_buf);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3136 printf("%X: %s\n", address, input_buf);
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
3137 debugger_repl(root);
1329
85a90964b557 Fix interaction between 68K debugger and instruction retranslation due to self modifying code or bank switching
Michael Pavone <pavone@retrodev.com>
parents: 1314
diff changeset
3138 return;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3139 }