Mercurial > repos > blastem

annotate debug.c @ 2359:04d29635d238

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Support for arrays in debugger language
author Michael Pavone <pavone@retrodev.com>
date Sat, 28 Oct 2023 14:39:19 -0700
parents 4b2ac43c106e
children 053ba4551c62
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"
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
17 #ifndef NO_Z80
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
18 #include "sms.h"
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
19 #endif
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
20
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 #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
22 #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
23 #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
24 #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
25 #endif
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26
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
27 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
28 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
29 #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
30
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 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
32 {
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 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
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 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
36 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
37 }
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 }
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 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
40 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
41 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
42 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
43 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
44 }
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
45 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
46 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 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
49 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 while (*cur) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 if ((*cur)->address == address) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 cur = &((*cur)->next);
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 return cur;
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
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 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
60 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 while (*cur) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 if ((*cur)->index == index) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 cur = &((*cur)->next);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
67 return cur;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
68 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
69
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
70 static const char *token_type_names[] = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
71 "TOKEN_NONE",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
72 "TOKEN_NUM",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
73 "TOKEN_NAME",
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
74 "TOKEN_OPER",
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
75 "TOKEN_SIZE",
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
76 "TOKEN_LBRACKET",
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
77 "TOKEN_RBRACKET",
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
78 "TOKEN_LPAREN",
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
79 "TOKEN_RPAREN"
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
80 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
81
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
82 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
83 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
84 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
85 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
86 ++start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
87 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
88 if (!*start || *start == '\n' || *start == '\r') {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
89 return (token){
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
90 .type = TOKEN_NONE
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
91 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
92 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
93 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
94 if (*start == '$' || (*start == '0' && start[1] == 'x')) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
95 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
96 .type = TOKEN_NUM,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
97 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
98 .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
99 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
100 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
101 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
102 if (isdigit(*start)) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
103 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
104 .type = TOKEN_NUM,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
105 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
106 .num = strtol(start, end, 10)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
107 }
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 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
110 switch (*start)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
111 {
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 case '~':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
120 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
121 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
122 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
123 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
124 if ((*start == '!' || *start == '>' || *start == '<') && start[1] == '=') {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
125 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
126 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
127 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
128 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
129 .op = {*start, start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
130 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
131 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
132 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
133 *end = start + 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
134 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
135 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
136 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
137 .op = {*start, 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
138 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
139 };
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
140 case '.':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
141 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
142 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
143 .type = TOKEN_SIZE,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
144 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
145 .op = {start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
146 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
147 };
2170
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_LBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
152 };
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
153 case ']':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
154 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
155 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
156 .type = TOKEN_RBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
157 };
2171
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_LPAREN
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
162 };
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
163 case ')':
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
164 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
165 return (token) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
166 .type = TOKEN_RPAREN
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
167 };
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
168 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
169 *end = start + 1;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
170 token_type type = TOKEN_NAME;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
171 while (**end && !isspace(**end))
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
172 {
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
173 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
174 switch (**end)
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
175 {
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
176 case '[':
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
177 type = TOKEN_ARRAY;
2172
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 case '/':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
182 case '&':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
183 case '|':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
184 case '^':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
185 case '~':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
186 case '=':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
187 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
188 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
189 case '<':
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
190 case '.':
2357
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
191 case ']':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
192 case '(':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
193 case ')':
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
194 done = 1;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
195 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
196 }
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
197 if (done) {
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
198 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
199 }
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
200
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
201 ++*end;
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 char *name = malloc(*end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
204 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
205 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
206 return (token) {
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
207 .type = type,
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
208 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
209 .str = name
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 };
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
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
214 static void free_expr(expr *e)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
215 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
216 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
217 return;
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 free_expr(e->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
220 free_expr(e->right);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
221 if (e->op.type == TOKEN_NAME) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
222 free(e->op.v.str);
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 free(e);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
225 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
226
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
227 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
228 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
229
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
230 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
231 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
232 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
233 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
234 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
235 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
236 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
237 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
238 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
239 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
240 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
241 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
242 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
243 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
244 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
245 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
246 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
247 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
248 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
249 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
250 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
251 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
252 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
253 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
254 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
255 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
256 ret->type = EXPR_MEM;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
257 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
258 //current token is the array name
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
259 //consume the bracket token
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
260 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
261 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
262 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
263 ret->right->op = first;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
264 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
265
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
266 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
267 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
268 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
269 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
270 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
271 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
272 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
273 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
274 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
275 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
276 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
277 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
278 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
279 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
280 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
281 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
282 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
283 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
284 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
285 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
286 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
287 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
288 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
289 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
290 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
291 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
292 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
293 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
294 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
295 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
296 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
297 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
298 return ret;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
299 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
300 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
301 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
302 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
303 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
304 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
305 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
306 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
307 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
308 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
309 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
310 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
311 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
312 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
313 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
314 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
315 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
316 ret->left->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
317 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
318 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
319 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
320
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
321 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
322 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
323 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
324 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
325 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
326 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
327 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
328 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
329 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
330 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
331 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
332 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
333 switch (first.v.op[0])
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 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
336 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
337 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
338 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
339 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
340 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
341 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
342 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
343 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
344 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
345 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
346 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
347 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
348 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
349 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
350 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
351 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
352 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
353 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
354 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
355 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
356 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
357 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
358
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
359 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
360 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
361 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
362 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
363 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
364 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
365 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
366 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
367 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
368 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
369 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
370 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
371 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
372 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
373 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
374 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
375 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
376 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
377 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
378 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
379 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
380 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
381 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
382 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
383 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
384 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
385 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
386
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
387 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
388 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
389 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
390 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
391 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
392 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
393 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
394 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
395 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
396 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
397 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
398 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
399 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
400 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
401 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
402 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
403 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
404 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
405 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
406 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
407 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
408 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
409 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
410 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
411 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
412 ret->type = EXPR_MEM;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
413 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
414 //current token is the array name
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
415 //consume the bracket token
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
416 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
417 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
418 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
419 ret->right->op = first;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
420 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
421
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
422 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
423 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
424 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
425 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
426 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
427 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
428 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
429 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
430 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
431 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
432 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
433 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
434 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
435 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
436 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
437 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
438 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
439 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
440 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
441 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
442 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
443 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
444 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
445 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
446 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
447 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
448 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
449 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
450 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
451 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
452 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
453 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
454 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
455 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
456 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
457 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
458 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
459 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
460 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
461 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
462 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
463 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
464 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
465 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
466 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
467 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
468 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
469 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
470 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
471 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
472 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
473 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
474 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
475 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
476 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
477 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
478 return maybe_muldiv(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
479 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
480 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
481 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
482 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
483 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
484 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
485 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
486 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
487 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
488 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
489 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
490 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
491 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
492 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
493 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
494 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
495 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
496 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
497 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
498 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
499 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
500 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
501 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
502 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
503 } else {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
504 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
505 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
506 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
507 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
508 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
509 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
510 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
511
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
512 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
513 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
514 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
515 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
516 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
517 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
518 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
519 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
520 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
521 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
522 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
523 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
524 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
525 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
526 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
527 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
528 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
529 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
530 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
531 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
532 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
533 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
534 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
535 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
536 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
537 ret->type = EXPR_MEM;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
538 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
539 //current token is the array name
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
540 //consume the bracket token
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
541 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
542 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
543 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
544 ret->right->op = first;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
545 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
546
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
547 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
548 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
549 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
550 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
551 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
552 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
553 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
554 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
555 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
556 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
557 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
558 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
559 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
560 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
561 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
562 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
563 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
564 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
565 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
566 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
567 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
568 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
569 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
570 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
571 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
572 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
573 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
574 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
575 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
576 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
577 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
578 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
579 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
580 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
581 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
582 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
583 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
584 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
585 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
586 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
587 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
588 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
589 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
590 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
591 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
592 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
593 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
594 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
595 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
596 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
597 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
598 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
599 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
600 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
601 bin->right = parse_scalar(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
602 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
603 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
604 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
605 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
606 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
607 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
608 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
609 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
610 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
611 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
612 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
613 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
614 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
615 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
616 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
617 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
618 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
619 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
620 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
621 bin->right = parse_expression(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
622 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
623 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
624 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
625 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
626 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
627 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
628 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
629 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
630 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
631 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
632 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
633 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
634 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
635 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
636 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
637 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
638 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
639 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
640 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
641 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
642 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
643 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
644 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
645 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
646 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
647 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
648 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
649 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
650 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
651 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
652 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
653
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
654 static debug_array* full_array_resolve(debug_root *root, const char *name)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
655 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
656 debug_array *ret = root->array_resolve(root, name);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
657 if (!ret) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
658 ret = tern_find_ptr(root->arrays, name);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
659 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
660 return ret;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
661 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
662
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
663 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
664 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
665 uint32_t right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
666 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
667 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
668 case EXPR_SCALAR:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
669 if (e->op.type == TOKEN_NAME) {
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
670 if (root->resolve(root, e->op.v.str, out)) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
671 return 1;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
672 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
673 tern_val v;
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
674 if (tern_find(root->variables, e->op.v.str, &v)) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
675 *out = v.intval;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
676 return 1;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
677 }
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
678 if (tern_find(root->symbols, e->op.v.str, &v)) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
679 *out = v.intval;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
680 return 1;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
681 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
682 return 0;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
683 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
684 *out = e->op.v.num;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
685 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
686 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
687 case EXPR_UNARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
688 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
689 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
690 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
691 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
692 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
693 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
694 *out = !*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
695 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
696 case '~':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
697 *out = ~*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
698 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
699 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
700 *out = -*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
701 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
702 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
703 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
704 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
705 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
706 case EXPR_BINARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
707 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
708 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
709 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
710 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
711 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
712 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
713 *out += right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
714 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
715 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
716 *out -= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
717 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
718 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
719 *out *= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
720 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
721 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
722 *out /= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
723 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
724 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
725 *out &= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
726 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
727 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
728 *out |= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
729 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
730 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
731 *out ^= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
732 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
733 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
734 *out = *out == right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
735 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
736 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
737 *out = *out != right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
738 break;
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
739 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
740 *out = e->op.v.op[1] ? *out >= right : *out > right;
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
741 break;
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
742 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
743 *out = e->op.v.op[1] ? *out <= right : *out < right;
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
744 break;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
745 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
746 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
747 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
748 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
749 case EXPR_SIZE:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
750 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
751 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
752 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
753 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
754 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
755 case 'b':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
756 *out &= 0xFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
757 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
758 case 'w':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
759 *out &= 0xFFFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
760 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
761 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
762 return 1;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
763 case EXPR_MEM:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
764 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
765 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
766 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
767 if (e->right) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
768 debug_array *array = full_array_resolve(root, e->right->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
769 if (!array || *out >= array->size) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
770 return 0;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
771 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
772 *out = array->get(root, array, *out);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
773 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
774 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
775 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
776 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
777 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
778 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
779 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
780
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
781 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
782 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
783 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
784 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
785 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
786 return buf+1;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
787 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
788 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
789 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
790 return NULL;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
791 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
792
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
793 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
794 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
795 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
796 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
797 *buf = 0;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
798 return;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
799 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
800 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
801 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
802
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
803 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
804 {
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
805 //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
806 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
807 }
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
808
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
809 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
810 {
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
811 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
812 }
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
813
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
814 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
815 {
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
816 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
817 }
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
818
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
819 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
820 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
821 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
822 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
823 *out = m68k_read_byte(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
824 } else if (size == 'l') {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
825 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
826 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
827 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
828 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
829 *out = m68k_read_long(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
830 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
831 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
832 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
833 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
834 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
835 *out = m68k_read_word(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
836 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
837 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
838 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
839
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
840 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
841 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
842 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
843 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
844 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
845 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
846 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
847 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
848 return 0;
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 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
851 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
852 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
853 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
854 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
855 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
856 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
857 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
858 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
859 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
860 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
861
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
862 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
863 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
864 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
865 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
866 *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
867 } 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
868 *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
869 } else if (!strcasecmp(name, "sr")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
870 *out = context->status << 8;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
871 for (int flag = 0; flag < 5; flag++) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
872 *out |= context->flags[flag] << (4-flag);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
873 }
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
874 } else if(!strcasecmp(name, "cycle")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
875 *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
876 } else if (!strcasecmp(name, "pc")) {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
877 *out = root->address;
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
878 } else if (!strcasecmp(name, "sp")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
879 *out = context->aregs[7];
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
880 } 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
881 *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
882 } 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
883 *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
884 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
885 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
886 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
887 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
888 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
889
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
890 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
891 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
892 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
893 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
894 context->dregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
895 } 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
896 context->aregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
897 } else if (!strcasecmp(name, "sr")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
898 context->status = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
899 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
900 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
901 }
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
902 } else if (!strcasecmp(name, "sp")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
903 context->aregs[7] = value;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
904 } else if (!strcasecmp(name, "usp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
905 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
906 } else if (!strcasecmp(name, "ssp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
907 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
908 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
909 return 0;
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 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
912 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
913
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
914 static uint8_t resolve_vdp(debug_root *root, const char *name, uint32_t *out)
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
915 {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
916 m68k_context *m68k = root->cpu_context;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
917 genesis_context *gen = m68k->system;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
918 vdp_context *vdp = gen->vdp;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
919 if (!strcasecmp(name, "vcounter")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
920 *out = vdp->vcounter;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
921 } else if (!strcasecmp(name, "hcounter")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
922 *out = vdp->hslot;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
923 } else if (!strcasecmp(name, "address")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
924 *out = vdp->address;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
925 }else if (!strcasecmp(name, "cd")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
926 *out = vdp->cd;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
927 } else if (!strcasecmp(name, "status")) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
928 *out = vdp_status(vdp);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
929 } else {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
930 return 0;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
931 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
932 return 1;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
933 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
934
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
935 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
936 {
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
937
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
938 for (const char *cur = name; *cur; ++cur)
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
939 {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
940 if (*cur == ':') {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
941 if (cur - name == 3 && !memcmp(name, "vdp", 3)) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
942 return resolve_vdp(root, cur + 1, out);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
943 } else if (cur - name == 3 && !memcmp(name, "sub", 3)) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
944 m68k_context *m68k = root->cpu_context;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
945 genesis_context *gen = m68k->system;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
946 if (gen->expansion) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
947 segacd_context *cd = gen->expansion;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
948 root = find_m68k_root(cd->m68k);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
949 return root->resolve(root, cur + 1, out);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
950 } else {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
951 return 0;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
952 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
953 } else {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
954 return 0;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
955 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
956 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
957 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
958 if (resolve_m68k(root, name, out)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
959 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
960 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
961 m68k_context *m68k = root->cpu_context;
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
962 genesis_context *gen = m68k->system;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
963 if (!strcmp(name, "f") || !strcmp(name, "frame")) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
964 *out = gen->vdp->frame;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
965 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
966 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
967 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
968 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
969
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
970 static uint32_t debug_vram_get(debug_root *root, debug_array *array, uint32_t index)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
971 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
972 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
973 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
974 return gen->vdp->vdpmem[index];
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
975 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
976
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
977 static void debug_vram_set(debug_root *root, debug_array *array, uint32_t index, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
978 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
979 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
980 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
981 gen->vdp->vdpmem[index] = value;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
982 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
983
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
984 static uint32_t debug_vsram_get(debug_root *root, debug_array *array, uint32_t index)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
985 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
986 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
987 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
988 return gen->vdp->vsram[index] & VSRAM_BITS;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
989 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
990
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
991 static void debug_vsram_set(debug_root *root, debug_array *array, uint32_t index, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
992 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
993 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
994 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
995 gen->vdp->vsram[index] = value;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
996 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
997
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
998 static uint32_t debug_cram_get(debug_root *root, debug_array *array, uint32_t index)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
999 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1000 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1001 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1002 return gen->vdp->cram[index] & CRAM_BITS;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1003 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1004
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1005 static void debug_cram_set(debug_root *root, debug_array *array, uint32_t index, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1006 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1007 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1008 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1009 gen->vdp->cram[index] = value;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1010 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1011
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1012 static uint32_t debug_vreg_get(debug_root *root, debug_array *array, uint32_t index)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1013 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1014 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1015 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1016 return gen->vdp->regs[index];
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1017 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1018
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1019 static void debug_vreg_set(debug_root *root, debug_array *array, uint32_t index, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1020 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1021 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1022 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1023 vdp_reg_write(gen->vdp, index, value);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1024 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1025
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1026 static debug_array* resolve_vdp_array(debug_root *root, const char *name)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1027 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1028 static debug_array vram = {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1029 .get = debug_vram_get, .set = debug_vram_set,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1030 .size = VRAM_SIZE, .storage = VRAM_SIZE
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1031 };
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1032 static debug_array vsram = {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1033 .get = debug_vsram_get, .set = debug_vsram_set,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1034 };
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1035 static debug_array cram = {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1036 .get = debug_cram_get, .set = debug_cram_set,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1037 .storage = CRAM_SIZE, .size = CRAM_SIZE
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1038 };
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1039 static debug_array regs = {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1040 .get = debug_vreg_get, .set = debug_vreg_set,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1041 .storage = VDP_REGS, .size = VDP_REGS
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1042 };
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1043 if (!strcasecmp(name, "vram")) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1044 return &vram;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1045 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1046 if (!strcasecmp(name, "vsram")) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1047 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1048 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1049 vsram.storage = vsram.size = gen->vdp->vsram_size;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1050 return &vsram;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1051 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1052 if (!strcasecmp(name, "cram")) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1053 return &cram;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1054 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1055 if (!strcasecmp(name, "reg")) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1056 return &regs;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1057 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1058 return NULL;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1059 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1060
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1061 static debug_array* resolve_genesis_array(debug_root *root, const char *name)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1062 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1063 for (const char *cur = name; *cur; ++cur)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1064 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1065 if (*cur == ':') {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1066 if (cur - name == 3 && !memcmp(name, "vdp", 3)) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1067 return resolve_vdp_array(root, cur + 1);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1068 } /*else if (cur - name == 3 && !memcmp(name, "sub", 3)) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1069 m68k_context *m68k = root->cpu_context;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1070 genesis_context *gen = m68k->system;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1071 if (gen->expansion) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1072 segacd_context *cd = gen->expansion;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1073 root = find_m68k_root(cd->m68k);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1074 return root->resolve(root, cur + 1, out);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1075 } else {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1076 return NULL;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1077 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1078 }*/ else {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1079 return NULL;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1080 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1081 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1082 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1083 return NULL;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1084 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1085
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1086 static debug_array* resolve_null_array(debug_root *root, const char *name)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1087 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1088 return NULL;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1089 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1090
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1091 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
1092 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1093 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1094 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1095 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1096 free(full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1097 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1098
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1099 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
1100 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1101 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1102 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
1103 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1104 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1105 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1106 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1107 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1108 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1109 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1110 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
1111 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
1112 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1113 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1114 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1115 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1116 if (node->left || node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1117 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1118 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1119 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1120 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1121 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1122 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1123 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1124 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1125 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1126 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1127 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
1128 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
1129 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1130 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1131 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1132 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1133 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
1134 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1135 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1136 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1137 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1138 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1139 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1140 while (*cur && !isspace(*cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1141 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1142 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1143 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1144 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1145 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1146 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1147 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1148 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1149 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1150 if (*cur && *cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1151 ++cur;
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 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
1154 if (def->raw_args) {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1155 while (*cur && *cur != '\n')
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 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1158 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1159 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1160 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1161 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1162 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1163 raw_param[cur - text] = 0;
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 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1166 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1167 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1168 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1169 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1170 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1171 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1172 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1173 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
1174 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1175 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1176 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
1177 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1178 while (*text && *text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1179 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1180 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1181 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1182 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1183 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1184 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1185 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1186 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
1187 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1188 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1189 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1190 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
1191 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1192 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1193 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1194 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
1195 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
1196 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
1197 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1198 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1199 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1200 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1201 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1202 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1203 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
1204 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1205 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1206 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1207 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1208 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1209 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1210 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1211 out->format = format;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
1212
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1213 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1214 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1215 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1216 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
1217 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1218 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1219 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1220 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1221 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
1222 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1223 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1224 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1225 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1226 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1227
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
1228 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
1229 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
1230 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1231 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
1232 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1233 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
1234 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1235 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
1236 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1237
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1238 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
1239 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1240 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1241 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1242 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
1243 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1244 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1245 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1246 }
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
1247 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
1248 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
1249 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1250 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1251
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
1252 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
1253 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
1254 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
1255 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
1256 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
1257 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
1258 };
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1259
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1260 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
1261 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1262 ++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
1263 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
1264 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1265 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
1266 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1267 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
1268 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
1269 #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
1270 #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
1271 #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
1272 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
1273 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
1274 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
1275 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
1276 #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
1277 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
1278 process_events();
2302
0343f0d5add0 Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents: 2252
diff changeset
1279 #ifndef IS_LIB
2252
6a07b13894f7 Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2216
diff changeset
1280 render_update_display();
2302
0343f0d5add0 Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents: 2252
diff changeset
1281 #endif
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
1282 #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
1283 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
1284 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
1285 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
1286 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
1287 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
1288 }
e17d99c96c89 Make blocks an 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 #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
1290 } 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
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 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
1293 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
1294 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
1295 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
1296 }
e17d99c96c89 Make blocks an 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 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
1298 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
1299 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
1300 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1301 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
1302 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
1303 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
1304 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1305 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
1306 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
1307 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1308 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1309 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
1310 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
1311 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
1312 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1313 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
1314 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
1315 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
1316 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
1317 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
1318 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1319 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
1320 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
1321 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
1322 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1323 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
1324 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1325 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
1326 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
1327 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
1328 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
1329 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
1330 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
1331 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
1332 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
1333 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
1334 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
1335 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
1336 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1337 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
1338 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
1339 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
1340 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1341 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
1342 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
1343 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
1344 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
1345 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1346 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1347 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1348 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
1349 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1350
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1351 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
1352 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1353 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
1354 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
1355 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1356 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
1357 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
1358 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
1359 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1360 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1361 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1362 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
1363 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1364
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1365 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
1366 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1367
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1368 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
1369 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
1370 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
1371 uint8_t has_last = 0;
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1372 if (root->last_cmd.def) {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1373 memcpy(cmds + 1, &root->last_cmd, sizeof(root->last_cmd));
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1374 has_last = 1;
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1375 }
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
1376 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
1377 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
1378 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1379 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
1380 debugging = run_command(root, cmds + cur);
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1381 cur = !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
1382 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
1383 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
1384 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
1385 }
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1386 has_last = 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
1387 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
1388 case EMPTY:
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1389 if (has_last) {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1390 debugging = run_command(root, cmds + !cur);
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1391 }
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
1392 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
1393 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1394 }
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1395 if (has_last) {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1396 memcpy(&root->last_cmd, cmds + !cur, sizeof(root->last_cmd));
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1397 } else {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1398 free_parsed_command(cmds + !cur);
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1399 }
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1400 free_parsed_command(cmds + 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
1401 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1402
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1403 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
1404 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1405 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1406 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1407
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1408 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1409 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1410 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1411 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1412
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1413 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
1414 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1415 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1416 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1417 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1418 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1419 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1420 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1421 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1422 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1423 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1424 state->longest_command = len;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1427
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1428 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
1429 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1430 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1431 def->visited = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1432 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1433
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1434 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
1435 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1436 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1437 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1438 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1439 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1440 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1441 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1442 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1443 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1444 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1445 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1446 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1447 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1448 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
1449 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1450 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1451 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1452 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1453 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1454 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1455 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
1456 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1457 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1458 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1459 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1460 split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1461 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1462 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1463 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
1464 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1465 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1466 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1467 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1468 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1469 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1470 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1471 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1472 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1473 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1474 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1475 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1476 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1477 putchar(',');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1478 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1479 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
1480 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1481 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1482 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1483 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1484 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1485 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1486 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1487 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1488 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1489 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1490 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1491 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
1492 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1493 fputs(extra_desc, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1494 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1495 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1496 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1497
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
1498 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
1499 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1500 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1501 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
1502 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
1503 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
1504 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
1505 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1506 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1507
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
1508 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
1509 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1510 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1511 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1512
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
1513 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
1514 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1515 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1516 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1517 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1518 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1519 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1520 case 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1521 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1522 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1523 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1524 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1525 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1526 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1527 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
1528 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1529 }
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
1530 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1531
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1532 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
1533 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1534 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
1535 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
1536 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
1537 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
1538 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
1539 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1540 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
1541 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
1542 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
1543 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
1544 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
1545 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1546 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
1547 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1548 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
1549 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
1550 } 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
1551 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
1552 }
e17d99c96c89 Make blocks an 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 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1554
e17d99c96c89 Make blocks an 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 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
1556 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1557 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
1558 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
1559 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
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 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
1562 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1563 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1564 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1565
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
1566 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
1567 {
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
1568 char *param = cmd->raw;
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1569 if (!param) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1570 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
1571 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1572 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1573 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1574 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1575 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1576 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1577 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1578 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
1579 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1580 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1581 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1582 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1583 char *cur = param, *out = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1584 while (*cur && *cur != '"')
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1585 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1586 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1587 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1588 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1589 case 't':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1590 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1591 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1592 case 'n':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1593 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1594 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1595 case 'r':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1596 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1597 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1598 case '\\':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1599 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1600 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1601 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1602 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
1603 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1604 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1605 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1606 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1607 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1608 *(out++) = *(cur++);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1609 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1610 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1611 *out = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1612 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1613 param = cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1614 cur = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1615 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1616 while (*cur)
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1617 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1618 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1619 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1620 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1621 case 'x':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1622 case 'X':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1623 case 'c':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1624 case 'd':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1625 case 's':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1626 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1627 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1628 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
1629 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1630 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1631 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1632 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1633 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1634 if (!arg) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1635 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1636 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1637 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1638 uint32_t val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1639 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1640 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1641 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1642 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1643 if (cur[1] == 's') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1644 char tmp[128];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1645 int j;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1646 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
1647 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1648 uint32_t addr = val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1649 root->read_mem(root, &addr, 'b');
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1650 char c = addr;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1651 if (c < 0x20 || c > 0x7F) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1652 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1653 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1654 tmp[j] = c;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1655 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1656 tmp[j] = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1657 printf(format_str, tmp);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1658 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1659 printf(format_str, val);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1660 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1661 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1662 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1663 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1664 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1665 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1666 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1667 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1668 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1669
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
1670 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
1671 {
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
1672 cmd_print(root, cmd);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1673 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
1674 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1675 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
1676 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
1677 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
1678 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
1679 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
1680 cmd->num_args = 0;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1681 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1682 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
1683 return 1;
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
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
1686 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
1687 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1688 disp_def **cur = &root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1689 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1690 {
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
1691 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
1692 disp_def *del_disp = *cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1693 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1694 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1695 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
1696 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1697 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1698 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
1699 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1700 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1701 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1702 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1703 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1704 cur = &(*cur)->next;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1707 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1708 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1709
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
1710 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
1711 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1712 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1713 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1714 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1715 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1716 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
1717 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1718 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1719 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1720
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
1721 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
1722 {
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
1723 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
1724 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
1725 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
1726 return 1;
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 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
1729 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1730 free_parsed_command((*target)->commands + i);
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 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
1733 (*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
1734 (*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
1735 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
1736 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
1737 return 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1738 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1739
2190
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1740 static uint8_t execute_block(debug_root *root, command_block * block)
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1741 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1742 uint8_t debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1743 for (int i = 0; i < block->num_commands; i++)
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1744 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1745 debugging = run_command(root, block->commands + i) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1746 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1747 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1748 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1749
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1750 static uint8_t cmd_if(debug_root *root, parsed_command *cmd)
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1751 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1752 return execute_block(root, cmd->args[0].value ? &cmd->block : &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1753 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1754
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1755 static uint8_t cmd_while(debug_root *root, parsed_command *cmd)
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1756 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1757 if (!cmd->args[0].value) {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1758 return execute_block(root, &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1759 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1760 int debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1761 do {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1762 debugging = execute_block(root, &cmd->block) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1763 if (!eval_expr(root, cmd->args[0].parsed, &cmd->args[0].value)) {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1764 fprintf(stderr, "Failed to eval %s\n", cmd->args[0].raw);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1765 return 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1766 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1767 } while (cmd->args[0].value);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1768 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1769 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1770
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1771 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1772 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1773 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1774 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1775 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1776 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1777 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1778 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1779
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
1780 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
1781 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1782 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1783 char size = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1784 uint32_t address;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1785 debug_array *array = NULL;
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
1786 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
1787 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1788 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
1789 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
1790 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
1791 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1792 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
1793 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1794 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1795 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1796 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
1797 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
1798 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
1799 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
1800 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1801 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
1802 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1803 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1804 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1805 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
1806 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
1807 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
1808 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
1809 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1810 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1811 if (cmd->args[0].parsed->right) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1812 array = full_array_resolve(root, cmd->args[0].parsed->right->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1813 if (!array) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1814 fprintf(stderr, "Failed to resolve array %s\n", cmd->args[0].parsed->right->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1815 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1816 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1817 if (!array->set) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1818 fprintf(stderr, "Array %s is read-only\n", cmd->args[0].parsed->right->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1819 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1820 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1821 if (address >= array->size) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1822 fprintf(stderr, "Address %X is out of bounds for array %s\n", address, cmd->args[0].parsed->right->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1823 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1824 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1825 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1826 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1827 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
1828 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
1829 return 1;
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 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
1832 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
1833 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1834 }
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
1835 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
1836 if (name && size && size != 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1837 uint32_t old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1838 if (!root->resolve(root, name, &old)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1839 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
1840 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1841 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1842 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1843 old &= 0xFFFFFF00;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1844 value &= 0xFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1845 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
1846 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1847 old &= 0xFFFF0000;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1848 value &= 0xFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1849 value |= old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1850 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1851 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1852 if (name) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1853 if (!root->set(root, name, value)) {
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1854 tern_val v;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1855 if (tern_find(root->variables, name, &v)) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1856 root->variables = tern_insert_int(root->variables, name, value);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1857 } else {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1858 fprintf(stderr, "Failed to set %s\n", name);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1859 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1860 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1861 } else if (array) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1862 array->set(root, array, address, value);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1863 } 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
1864 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
1865 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1866 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1867 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1868
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1869 static uint8_t cmd_variable(debug_root *root, parsed_command *cmd)
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1870 {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1871 if (cmd->args[0].parsed->type != EXPR_SCALAR || cmd->args[0].parsed->op.type != TOKEN_NAME) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1872 fprintf(stderr, "First argument to variable must be a name, got %s\n", expr_type_names[cmd->args[0].parsed->type]);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1873 return 1;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1874 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1875 uint32_t value = 0;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1876 if (cmd->num_args > 1) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1877 if (!eval_expr(root, cmd->args[1].parsed, &cmd->args[1].value)) {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1878 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1879 return 1;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1880 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1881 value = cmd->args[1].value;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1882 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1883 root->variables = tern_insert_int(root->variables, cmd->args[0].parsed->op.v.str, value);
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1884 return 1;
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1885 }
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
1886
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1887 static uint32_t user_array_get(debug_root *root, debug_array *array, uint32_t index)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1888 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1889 return array->data[index];
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1890 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1891
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1892 static void user_array_set(debug_root *root, debug_array *array, uint32_t index, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1893 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1894 array->data[index] = value;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1895 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1896
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1897 static void user_array_append(debug_root *root, debug_array *array, uint32_t value)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1898 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1899 if (array->size == array->storage) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1900 array->storage *= 2;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1901 array->data = realloc(array->data, sizeof(uint32_t) * array->storage);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1902 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1903 array->data[array->size++] = value;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1904 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1905
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1906 static uint8_t cmd_array(debug_root *root, parsed_command *cmd)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1907 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1908 if (cmd->args[0].parsed->type != EXPR_SCALAR || cmd->args[0].parsed->op.type != TOKEN_NAME) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1909 fprintf(stderr, "First argument to array must be a name, got %s\n", expr_type_names[cmd->args[0].parsed->type]);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1910 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1911 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1912 debug_array *array = tern_find_ptr(root->arrays, cmd->args[0].parsed->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1913 if (!array) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1914 array = calloc(1, sizeof(debug_array));
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1915 array->get = user_array_get;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1916 array->set = user_array_set;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1917 array->append = user_array_append;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1918 array->storage = cmd->num_args > 1 ? cmd->num_args - 1 : 4;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1919 array->data = calloc(array->storage, sizeof(uint32_t));
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1920 root->arrays = tern_insert_ptr(root->arrays, cmd->args[0].parsed->op.v.str, array);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1921 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1922 array->size = cmd->num_args - 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1923 for (uint32_t i = 1; i < cmd->num_args; i++)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1924 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1925 if (!eval_expr(root, cmd->args[i].parsed, &cmd->args[i].value)) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1926 fprintf(stderr, "Failed to eval %s\n", cmd->args[i].raw);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1927 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1928 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1929 array->set(root, array, i - 1, cmd->args[i].value);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1930 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1931 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1932 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1933
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1934 static uint8_t cmd_append(debug_root *root, parsed_command *cmd)
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1935 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1936 if (cmd->args[0].parsed->type != EXPR_SCALAR || cmd->args[0].parsed->op.type != TOKEN_NAME) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1937 fprintf(stderr, "First argument to append must be a name, got %s\n", expr_type_names[cmd->args[0].parsed->type]);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1938 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1939 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1940 debug_array *array = full_array_resolve(root, cmd->args[0].parsed->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1941 if (!array) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1942 fprintf(stderr, "Failed to resolve array %s\n", cmd->args[0].parsed->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1943 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1944 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1945 if (!array->append) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1946 fprintf(stderr, "Array %s doesn't support appending\n", cmd->args[0].parsed->op.v.str);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1947 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1948 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1949 if (!eval_expr(root, cmd->args[1].parsed, &cmd->args[1].value)) {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1950 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1951 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1952 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1953 array->append(root, array, cmd->args[1].value);
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1954 return 1;
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1955 }
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
1956
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
1957 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
1958 {
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
1959 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
1960 return 0;
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1961 }
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1962
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
1963 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
1964 {
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
1965 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
1966 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
1967 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1968 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1969 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1970
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
1971 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
1972 {
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
1973 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
1974 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
1975 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1976 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1977 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1978
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
1979 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
1980 {
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
1981 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
1982 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
1983 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1984 }
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
1985 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
1986 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
1987 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
1988 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1989 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1990 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
1991 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
1992 (*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
1993 cmd->args[1].parsed = NULL;
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1994 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1995 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1996 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1997 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1998 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1999
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2000 static void symbol_max_len(char *key, tern_val val, uint8_t valtype, void *data)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2001 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2002 size_t *max_len = data;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2003 size_t len = strlen(key);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2004 if (len > *max_len) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2005 *max_len = len;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2006 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2007 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2008
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2009 static void print_symbol(char *key, tern_val val, uint8_t valtype, void *data)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2010 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2011 size_t *padding = data;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2012 size_t len = strlen(key);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2013 fputs(key, stdout);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2014 while (len < *padding)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2015 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2016 putchar(' ');
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2017 len++;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2018 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2019 printf("%X\n", (uint32_t)val.intval);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2020 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2021
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2022 static uint8_t cmd_symbols(debug_root *root, parsed_command *cmd)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2023 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2024 char *filename = cmd->raw ? strip_ws(cmd->raw) : NULL;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2025 if (filename && *filename) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2026 FILE *f = fopen(filename, "r");
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2027 if (!f) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2028 fprintf(stderr, "Failed to open %s for reading\n", filename);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2029 return 1;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2030 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2031 char linebuf[1024];
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2032 while (fgets(linebuf, sizeof(linebuf), f))
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2033 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2034 char *line = strip_ws(linebuf);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2035 if (*line) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2036 char *end;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2037 uint32_t address = strtol(line, &end, 16);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2038 if (end != line) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2039 if (*end == '=') {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2040 char *name = strip_ws(end + 1);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2041 add_label(root->disasm, name, address);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2042 root->symbols = tern_insert_int(root->symbols, name, address);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2043 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2044 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2045 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2046 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2047 } else {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2048 size_t max_len = 0;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2049 tern_foreach(root->symbols, symbol_max_len, &max_len);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2050 max_len += 2;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2051 tern_foreach(root->symbols, print_symbol, &max_len);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2052 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2053 return 1;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2054 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2055
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
2056 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
2057 {
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
2058 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
2059 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
2060 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
2061 return 1;
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 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2064 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
2065 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2066 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2067 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
2068 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2069 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2070 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2071 free(tmp->commands);
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 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2074 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2075 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2076
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
2077 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
2078 {
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
2079 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
2080 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
2081 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
2082 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
2083 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2084 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
2085 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
2086 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2087 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2088
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
2089 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
2090 {
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
2091 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
2092 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2093 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2094
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
2095 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
2096 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2097 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2098 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2099 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2100 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2101 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
2102 } 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
2103 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
2104 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2105 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
2106 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2107 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
2108 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
2109 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2110 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2111 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
2112 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
2113 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2114 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2115 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2116 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
2117 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
2118 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2119 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2120 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
2121 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2122 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2123 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
2124 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2125 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2126
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
2127 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
2128 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2129 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2130 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2131 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2132 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2133 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
2134 } 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
2135 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
2136 } 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
2137 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
2138 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
2139 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2140 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2141 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2142 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2143 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
2144 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2145 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2146 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
2147 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2148 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2149 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2150 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2151 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2152 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2153 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
2154 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2155 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2156 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2157 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
2158 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2159 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2160 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
2161 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2162 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2163
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
2164 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
2165 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2166 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2167 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2168 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2169 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2170 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
2171 } 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
2172 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
2173 } 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
2174 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
2175 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2176 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
2177 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
2178 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2179 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2180 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
2181 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
2182 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2183 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2184 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2185 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
2186 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
2187 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2188 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2189 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
2190 }
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 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
2193 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2194 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2195
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 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
2197 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2198 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2199 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2200 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2201 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2202 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
2203 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
2204 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2205 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2206 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2207 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2208 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2209 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
2210 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2211 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
2212 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2213 //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
2214 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2215 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2216 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2217 //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
2218 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2219 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2220 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2221
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2222 static uint8_t cmd_disassemble_m68k(debug_root *root, parsed_command *cmd)
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2223 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2224 m68k_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2225 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2226 if (cmd->num_args) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2227 address = cmd->args[0].value;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2228 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2229 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2230 m68kinst inst;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2231 do {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2232 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2233 if (def) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2234 for (uint32_t i = 0; i < def->num_labels; i++)
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2235 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2236 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2237 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2238 }
2252
6a07b13894f7 Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2216
diff changeset
2239
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2240 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2241 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2242 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2243 } while(!m68k_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2244 return 1;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2245 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2246
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
2247 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
2248 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2249 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2250 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2251 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2252 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2253 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2254
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
2255 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
2256 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2257 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2258 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2259 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2260 return 1;
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
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
2263 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
2264 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2265 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2266 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
2267 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
2268 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
2269 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2270 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
2271 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
2272 }
2173
894c7873a2b1 Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 2172
diff changeset
2273 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2274 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2275 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2276
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
2277 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
2278 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2279 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2280 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2281 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2282 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2283 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2284
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
2285 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
2286 {
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
2287 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2288 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2289 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2290 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2291 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2292 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2293 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2294 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2295 if (param && *param && !isspace(*param)) {
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
2296 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2297 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
2298 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2299 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
2300 return 1;
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 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
2303 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2304 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2305 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
2306 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2307 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2308 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2309 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2310 return 0;
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
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
2314 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
2315 {
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
2316 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2317 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2318 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2319 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2320 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2321 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2322 segacd_context *cd = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2323
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2324 if (param && *param && !isspace(*param)) {
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
2325 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2326 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
2327 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2328 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
2329 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2330 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2331 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
2332 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2333 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2334 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
2335 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2336 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2337 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2338 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2339 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2340 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2341 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2342
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
2343 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
2344 {
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
2345 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2346 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2347 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2348 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2349 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2350 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2351 genesis_context *gen = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2352
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2353 if (param && *param && !isspace(*param)) {
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
2354 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2355 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
2356 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2357 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
2358 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2359 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2360 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
2361 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2362 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2363 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
2364 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2365 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2366 } else {
2184
408fb8a7e990 Implement argumentless variant of z80 debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2183
diff changeset
2367 gen->enter_z80_debugger = 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2368 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2369 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2370 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2371
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2372 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2373 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2374 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2375 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2376 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2377 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2378 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2379 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2380 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2381 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2382 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2383 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2384 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2385 "help", "?", NULL
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 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2388 .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
2389 .impl = cmd_help,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2390 .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
2391 .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
2392 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2393 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2394 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2395 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2396 "continue", "c", NULL
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 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2399 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2400 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2401 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2402 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2403 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2404 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2405 .names = (const char *[]){
2189
6b33ce6bc740 Add an explicit p alias for the print command now that printf prevents use of it as an implicit alias
Michael Pavone <pavone@retrodev.com>
parents: 2188
diff changeset
2406 "print", "p", NULL
2178
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 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2409 .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
2410 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2411 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2412 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2413 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2414 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2415 .names = (const char *[]){
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2416 "printf", NULL
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2417 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2418 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2419 .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
2420 .impl = cmd_printf,
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2421 .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
2422 .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
2423 .raw_args = 1
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2424 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2425 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2426 .names = (const char *[]){
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2427 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2428 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2429 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2430 .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
2431 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2432 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2433 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2434 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2435 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2436 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2437 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2438 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2439 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2440 .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
2441 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2442 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2443 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2444 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2445 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2446 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2447 "deletedisplay", "dd", NULL
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 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2450 .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
2451 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2452 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2453 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2454 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2455 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2456 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2457 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2458 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2459 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2460 .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
2461 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2462 .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
2463 .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
2464 .has_block = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2465 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2466 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2467 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2468 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2469 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2470 .usage = "set MEM|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2471 .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
2472 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2473 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2474 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2475 .skip_eval = 1
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2476 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2477 {
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2478 .names = (const char *[]){
2358
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2479 "variable", NULL
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2480 },
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2481 .usage = "variable NAME [VALUE]",
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2482 .desc = "Create a new variable called NAME and set it to VALUE or 0 if no value provided",
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2483 .impl = cmd_variable,
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2484 .min_args = 1,
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2485 .max_args = 2,
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2486 .skip_eval = 1
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2487 },
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2488 {
4b2ac43c106e Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents: 2357
diff changeset
2489 .names = (const char *[]){
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2490 "array", NULL
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2491 },
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2492 .usage = "array NAME [VALUE...]",
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2493 .desc = "Create a new array called NAME if it doesn't already exist. The array is initialized with the remaining parameters",
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2494 .impl = cmd_array,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2495 .min_args = 1,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2496 .max_args = -1,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2497 .skip_eval = 1
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2498 },
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2499 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2500 .names = (const char *[]){
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2501 "append", NULL
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2502 },
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2503 .usage = "append NAME VALUE",
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2504 .desc = "Increase the size of array NAME by 1 and set the last element to VALUE",
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2505 .impl = cmd_append,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2506 .min_args = 2,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2507 .max_args = 2,
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2508 .skip_eval = 1
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2509 },
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2510 {
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
2511 .names = (const char *[]){
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2512 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2513 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2514 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2515 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2516 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2517 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2518 .max_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2519 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2520 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2521 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2522 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2523 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2524 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2525 .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
2526 .impl = cmd_bindup,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2527 .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
2528 .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
2529 .raw_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2530 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2531 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2532 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2533 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2534 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2535 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2536 .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
2537 .impl = cmd_binddown,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2538 .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
2539 .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
2540 .raw_args = 1
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2541 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2542 {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2543 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2544 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2545 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2546 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2547 .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
2548 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2549 .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
2550 .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
2551 .skip_eval = 1
2190
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2552 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2553 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2554 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2555 "if", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2556 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2557 .usage = "if CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2558 .desc = "If the condition is true, the following block is executed. Otherwise the else block is executed if present",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2559 .impl = cmd_if,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2560 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2561 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2562 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2563 .accepts_else = 1
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2564 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2565 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2566 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2567 "while", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2568 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2569 .usage = "while CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2570 .desc = "The following block is executed repeatedly until the condition is false. If the condition is false at the start, the else block is executed if present",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2571 .impl = cmd_while,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2572 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2573 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2574 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2575 .accepts_else = 1
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2576 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2577 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2578 .names = (const char *[]){
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2579 "symbols", NULL
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2580 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2581 .usage = "symbols [FILENAME]",
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2582 .desc = "Loads a list of symbols from the file indicated by FILENAME or lists currently loaded symbols if FILENAME is omitted",
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2583 .impl = cmd_symbols,
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2584 .min_args = 0,
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2585 .max_args = 1,
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2586 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2587 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2588 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2589 #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
2590
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2591 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2592 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2593 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2594 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2595 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2596 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2597 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2598 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2599 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2600 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2601 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2602 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2603 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2604 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2605 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2606 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2607 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2608 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2609 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2610 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2611 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2612 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2613 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2614 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2615 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2616 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2617 .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
2618 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2619 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2620 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2621 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2622 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2623 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2624 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2625 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2626 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2627 .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
2628 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2629 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2630 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2631 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2632 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2633 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2634 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2635 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2636 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2637 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2638 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2639 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2640 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2641 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2642 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2643 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2644 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2645 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2646 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2647 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2648 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2649 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2650 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2651 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2654 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2655 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2656 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2657 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2658 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2659 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2660 .max_args = 1
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2661 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2662 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2663 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2664 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2665 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2666 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2667 .desc = "Disassemble code starting at ADDRESS if provided or the current address if not",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2668 .impl = cmd_disassemble_m68k,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2669 .min_args = 0,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2670 .max_args = 1
2112
3abb64bd0da6 Add support for printing strings in 68K debugger
Michael Pavone <pavone@retrodev.com>
parents: 2107
diff changeset
2671 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2672 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2673
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2674 #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
2675
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2676 command_def genesis_commands[] = {
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2679 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2680 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2681 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2682 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2683 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2684 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2685 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2686 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2687 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2688 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2689 "vdpsregs", "vr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2690 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2691 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2692 .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
2693 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2694 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2695 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2696 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2697 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2698 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2699 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2700 "z80", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2701 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2702 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2703 .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
2704 .impl = cmd_gen_z80,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2705 .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
2706 .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
2707 .raw_args = 1
2178
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 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2710 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2711 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2712 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2713 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2714 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2715 .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
2716 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2717 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2718 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2719 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2722 "ymtimer", "yt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2723 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2724 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2725 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2726 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2727 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2728 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2729 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2730 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2731
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2732 #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
2733
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2734 command_def scd_main_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2735 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2736 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2737 "subcpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2738 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2739 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2740 .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
2741 .impl = cmd_sub,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2742 .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
2743 .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
2744 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2745 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2746 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2747
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2748 #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
2749
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2750 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2751 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2752 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2753 "maincpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2754 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2755 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2756 .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
2757 .impl = cmd_main,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2758 .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
2759 .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
2760 .raw_args = 1
2178
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 };
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 #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
2765
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2766 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2767
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
2768 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
2769 {
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
2770 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
2771 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
2772 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
2773 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2774 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2775 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2776 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
2777 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2778 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2779 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
2780 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2781 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2782 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2783 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2784 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2785 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2786 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2787 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2788
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
2789 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
2790 {
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
2791 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
2792 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
2793 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
2794 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
2795 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2796 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
2797 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
2798 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2799 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2800
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
2801 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
2802 {
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
2803 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
2804 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2805 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2806
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
2807 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
2808 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2809 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2810 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2811 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2812 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2813 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
2814 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2815 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2816 } 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
2817 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2818 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
2819 } 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
2820 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
2821 } 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
2822 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
2823 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2824 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2825 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2826 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2827 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2828 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
2829 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2830 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2831 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
2832 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2833 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2834 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2835 }
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 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
2838 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2839 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2840
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
2841 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
2842 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2843 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2844 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2845 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2846
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
2847 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
2848 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2849 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2850 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2851 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2852 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2853 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2854 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2855 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2856 } 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
2857 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2858 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
2859 } 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
2860 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
2861 } 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
2862 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
2863 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2864 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2865 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2866 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2867 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2868 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
2869 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2870 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2871 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
2872 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2873 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2874 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2875 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2876 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2877 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
2878 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2879 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2880
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
2881 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
2882 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2883 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2884 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2885 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2886 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2887 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2888 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
2889 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2890 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2891 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
2892 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2893 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2894 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2895 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2896 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2897 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
2898 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2899 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2900 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
2901 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2902 //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
2903 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2904 non_adr_count++;
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 //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
2907 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2908 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2909 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2910
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2911 static uint8_t cmd_disassemble_z80(debug_root *root, parsed_command *cmd)
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2912 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2913 z80_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2914 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2915 if (cmd->num_args) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2916 address = cmd->args[0].value;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2917 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2918 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2919 z80inst inst;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2920 do {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2921 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2922 if (def) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2923 for (uint32_t i = 0; i < def->num_labels; i++)
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2924 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2925 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2926 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2927 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2928 uint8_t *pc = get_native_pointer(address, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2929 uint8_t *after = z80_decode(pc, &inst);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2930 z80_disasm(&inst, disasm_buf, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2931 address += after - pc;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2932 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2933 } while(!z80_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2934 return 1;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2935 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2936
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
2937 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
2938 {
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
2939 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
2940 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
2941 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2942 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2943 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2944 genesis_context *gen = (genesis_context *)current_system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2945
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2946 if (param && *param && !isspace(*param)) {
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
2947 parsed_command cmd = {0};
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2948 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
2949 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
2950 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
2951 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2952 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2953 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
2954 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2955 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2956 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
2957 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
2958 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2959 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2960 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
2961 return 0;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2962 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2963 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2964
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2965 static uint8_t cmd_vdp_sprites_sms(debug_root *root, parsed_command *cmd)
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2966 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2967 z80_context *context = root->cpu_context;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2968 sms_context * sms = context->system;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2969 vdp_print_sprite_table(sms->vdp);
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2970 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2971 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2972
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2973 static uint8_t cmd_vdp_regs_sms(debug_root *root, parsed_command *cmd)
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2974 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2975 z80_context *context = root->cpu_context;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2976 sms_context * sms = context->system;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2977 vdp_print_reg_explain(sms->vdp);
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2978 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2979 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2980
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2981 command_def z80_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2982 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2983 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2984 "breakpoint", "b", NULL
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 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2987 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2988 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2989 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2990 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2991 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2992 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2993 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2994 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2995 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2996 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2997 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2998 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2999 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3000 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3001 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3002 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3003 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3004 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3005 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3006 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3007 .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
3008 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3009 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3010 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3011 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3012 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3013 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3014 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3015 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3016 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3017 .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
3018 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3019 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3020 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3021 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3022 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3023 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3024 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3025 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3026 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3027 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3028 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3029 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3030 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3031 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3032 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3033 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3034 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3035 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3036 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3037 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3038 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3039 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3040 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3041 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3042 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3043 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3044 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3045 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3046 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3047 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3048 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3049 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3050 .max_args = 1
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3051 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3052 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3053 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3054 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3055 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3056 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3057 .desc = "Disassemble code starting at ADDRESS if provided or the current address if not",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3058 .impl = cmd_disassemble_z80,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3059 .min_args = 0,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3060 .max_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3061 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3062 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3063
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3064 #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
3065
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3066 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
3067 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3068 .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
3069 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3070 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3071 .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
3072 .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
3073 .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
3074 .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
3075 .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
3076 .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
3077 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3078 };
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3079
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3080 #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
3081
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3082 command_def sms_commands[] = {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3083 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3084 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3085 "vdpsprites", "vs", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3086 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3087 .usage = "vdpsprites",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3088 .desc = "Print the VDP sprite table",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3089 .impl = cmd_vdp_sprites_sms,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3090 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3091 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3092 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3093 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3094 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3095 "vdpsregs", "vr", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3096 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3097 .usage = "vdpregs",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3098 .desc = "Print VDP register values with a short description",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3099 .impl = cmd_vdp_regs_sms,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3100 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3101 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3102 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3103 };
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3104
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3105 #define NUM_SMS (sizeof(sms_commands)/sizeof(*sms_commands))
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3106
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3107 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3108
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3109 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
3110 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3111 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
3112 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3113 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
3114 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3115 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
3116 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3117 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3118 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3119
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3120 static void symbol_map(char *key, tern_val val, uint8_t valtype, void *data)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3121 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3122 debug_root *root = data;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3123 label_def *label = val.ptrval;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3124 for (uint32_t i = 0; i < label->num_labels; i++)
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3125 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3126 root->symbols = tern_insert_int(root->symbols, label->labels[i], label->full_address);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3127 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3128 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3129
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3130 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
3131 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3132 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3133 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3134 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
3135 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
3136 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3137 root->write_mem = write_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3138 root->set = set_m68k;
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3139 root->disasm = create_68000_disasm();
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3140 switch (current_system->type)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3141 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3142 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3143 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3144 //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
3145 if (context->system == current_system) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3146 root->resolve = resolve_genesis;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
3147 root->array_resolve = resolve_genesis_array;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3148 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
3149 if (current_system->type == SYSTEM_SEGACD) {
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3150 add_segacd_maincpu_labels(root->disasm);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3151 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
3152 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3153 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3154 } else {
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3155 add_segacd_subcpu_labels(root->disasm);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3156 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
3157 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3158 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3159 root->resolve = resolve_m68k;
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
3160 root->array_resolve = resolve_null_array;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3161 }
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3162 tern_foreach(root->disasm->labels, symbol_map, root);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3163 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3164 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
3165 }
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
3166
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
3167 #ifndef NO_Z80
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3168
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3169 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
3170 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3171 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3172 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3173 *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
3174 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3175 *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
3176 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3177 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3178 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3179
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3180 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
3181 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3182 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3183 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
3184 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3185 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
3186 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3187 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3188 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3189
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3190 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
3191 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3192 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3193 switch (tolower(name[0]))
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3194 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3195 case 'a':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3196 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3197 *out = context->regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3198 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3199 *out = context->alt_regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3200 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3201 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3202 *out = context->regs[Z80_A] << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3203 *out |= context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3204 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3205 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3206 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3207 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3208 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3209 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3210 *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
3211 *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
3212 *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
3213 *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
3214 *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
3215 *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
3216 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3217 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3218 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3219 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3220 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3221 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3222 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3223 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3224 case 'b':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3225 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3226 *out = context->regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3227 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3228 *out = context->alt_regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3229 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3230 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3231 *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
3232 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3233 *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
3234 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3235 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3236 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3237 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3238 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3239 case 'c':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3240 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3241 *out = context->regs[Z80_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3242 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3243 *out = context->alt_regs[Z80_C];
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3244 } else if (!strcmp(name + 1, "ycle")) {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3245 *out = context->current_cycle;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3246 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3247 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3248 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3249 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3250 case 'd':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3251 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3252 *out = context->regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3253 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3254 *out = context->alt_regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3255 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3256 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3257 *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
3258 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3259 *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
3260 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3261 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3262 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3263 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3264 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3265 case 'e':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3266 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3267 *out = context->regs[Z80_E];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3268 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3269 *out = context->alt_regs[Z80_E];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3270 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3271 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3272 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3273 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3274 case 'f':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3275 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3276 *out = context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3277 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3278 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3279 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3280 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3281 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3282 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3283 *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
3284 *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
3285 *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
3286 *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
3287 *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
3288 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3289 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3290 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3291 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3292 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3293 case 'h':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3294 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3295 *out = context->regs[Z80_H];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3296 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3297 *out = context->alt_regs[Z80_H];
2208
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3298 } else if (tolower(name[1]) == 'l') {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3299 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3300 *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
3301 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3302 *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
3303 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3304 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3305 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3306 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3307 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3308 case 'i':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3309 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3310 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3311 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3312 *out = context->regs[Z80_I];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3313 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3314 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3315 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
3316 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3317 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3318 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3319 *out = context->iff1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3320 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3321 *out = context->iff2;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3322 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3323 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3324 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3325 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3326 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3327 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3328 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3329 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3330 *out = context->im;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3331 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3332 case 'n':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3333 if (strcasecmp(name +2, "t_cycle")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3334 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3335 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3336 *out = context->int_cycle;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3337 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3338 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3339 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3340 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3341 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3342 *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
3343 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3344 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3345 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3346 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3347 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3348 *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
3349 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3350 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3351 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3352 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3353 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3354 *out = context->regs[Z80_IXH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3355 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3356 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3357 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3358 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3359 *out = context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3360 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3361 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3362 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3363 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3364 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3365 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3366 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3367 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3368 *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
3369 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3370 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3371 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3372 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3373 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3374 *out = context->regs[Z80_IYH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3375 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3376 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3377 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3378 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3379 *out = context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3380 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3381 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3382 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3383 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3384 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3385 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3386 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3387 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3388 case 'l':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3389 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3390 *out = context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3391 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3392 *out = context->alt_regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3393 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3394 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3395 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3396 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3397 case 'p':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3398 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
3399 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3400 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3401 *out = root->address;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3402 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3403 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3404 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3405 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3406 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3407 *out = context->regs[Z80_R];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3408 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3409 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
3410 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3411 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3412 *out = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3413 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3414 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3415 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3416 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3417 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3418 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3419
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3420 static uint8_t resolve_sms(debug_root *root, const char *name, uint32_t *out)
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3421 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3422 if (resolve_z80(root, name, out)) {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3423 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3424 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3425 z80_context *z80 = root->cpu_context;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3426 sms_context *sms = z80->system;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3427 if (!strcmp(name, "f") || !strcmp(name, "frame")) {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3428 *out = sms->vdp->frame;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3429 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3430 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3431 return 0;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3432 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3433
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3434 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
3435 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3436 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3437 switch (tolower(name[0]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3438 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3439 case 'a':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3440 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3441 context->regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3442 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3443 context->alt_regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3444 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3445 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3446 context->regs[Z80_A] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3447 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
3448 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
3449 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
3450 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
3451 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
3452 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3453 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3454 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
3455 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
3456 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
3457 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
3458 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
3459 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
3460 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
3461 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3462 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3463 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3464 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3465 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3466 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3467 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3468 case 'b':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3469 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3470 context->regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3471 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3472 context->alt_regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3473 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3474 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3475 context->regs[Z80_B] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3476 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3477 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3478 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
3479 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3480 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3481 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3482 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3483 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3484 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3485 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3486 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3487 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3488 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3489 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3490 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3491 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3492 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3493 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3494 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3495 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3496 context->regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3497 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3498 context->alt_regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3499 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3500 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3501 context->regs[Z80_D] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3502 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3503 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3504 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
3505 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3506 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3507 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3508 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3509 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3510 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3511 case 'e':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3512 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3513 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3514 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3515 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3516 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3517 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3518 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3519 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3520 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3521 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3522 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
3523 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
3524 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
3525 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
3526 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
3527 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3528 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3529 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
3530 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
3531 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
3532 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
3533 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
3534 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
3535 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3536 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3537 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3538 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3539 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3540 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3541 context->regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3542 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3543 context->alt_regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3544 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3545 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3546 context->regs[Z80_H] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3547 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3548 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3549 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
3550 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3551 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3552 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3553 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3554 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3555 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3556 case 'i':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3557 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3558 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3559 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3560 context->regs[Z80_I] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3561 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3562 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3563 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
3564 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3565 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3566 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3567 context->iff1 = value != 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3568 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3569 context->iff2 = value != 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3570 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3571 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3572 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3573 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3574 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3575 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3576 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3577 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3578 context->im = value & 3;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3579 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3580 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3581 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3582 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3583 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3584 context->regs[Z80_I] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3585 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3586 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3587 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3588 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3589 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3590 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3591 context->regs[Z80_IXH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3592 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3593 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3594 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3595 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3596 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3597 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3598 context->regs[Z80_IXH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3599 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3600 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3601 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3602 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3603 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3604 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3605 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3606 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3607 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3608 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3609 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3610 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3611 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3612 context->regs[Z80_IYH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3613 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3614 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3615 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3616 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3617 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3618 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3619 context->regs[Z80_IYH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3620 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3621 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3622 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3623 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3624 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3625 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3626 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3627 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3628 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3629 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3630 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3631 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3632 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3633 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3634 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3635 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3636 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3637 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3638 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3639 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3640 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3641 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3642 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3643 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3644 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3645 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3646 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3647 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3648 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
3649 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3650 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3651 context->sp = value;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3652 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3653 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3654 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3655 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3656 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3657 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3658
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3659 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
3660 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3661 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3662 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3663 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
3664 add_commands(root, z80_commands, NUM_Z80);
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3665 switch (current_system->type)
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3666 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3667 case SYSTEM_GENESIS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3668 case SYSTEM_SEGACD:
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3669 add_commands(root, gen_z80_commands, NUM_GEN_Z80);
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3670 root->resolve = resolve_z80;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3671 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3672 case SYSTEM_SMS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3673 root->resolve = resolve_sms;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3674 add_commands(root, sms_commands, NUM_SMS);
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3675 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3676 default:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3677 root->resolve = resolve_z80;
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
3678 }
2359
04d29635d238 Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents: 2358
diff changeset
3679 root->array_resolve = resolve_null_array;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3680 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3681 root->write_mem = write_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3682 root->set = set_z80;
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3683 root->disasm = create_z80_disasm();
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3684 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3685 return root;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3686 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3687
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3688 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
3689 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3690 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3691 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3692 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
3693 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
3694 init_terminal();
2180
b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor
Michael Pavone <pavone@retrodev.com>
parents: 2179
diff changeset
3695 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
3696 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
3697 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
3698 }
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
3699 root->address = address;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3700 //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
3701 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
3702 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3703 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3704 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3705 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3706 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3707 return context;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3708 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3709 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3710 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
3711 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3712 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3713 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3714 }
2208
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3715 int debugging = 1;
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3716 for (uint32_t i = 0; debugging && i < (*this_bp)->num_commands; i++)
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3717 {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3718 debugging = run_command(root, (*this_bp)->commands + i);
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3719 }
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3720 if (debugging) {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3721 printf("Z80 Breakpoint %d hit\n", (*this_bp)->index);
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3722 } else {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3723 return context;
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3724 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3725 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3726 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3727 }
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
3728 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
3729 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode
Michael Pavone <pavone@retrodev.com>
parents: 1111
diff changeset
3730 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
3731 }
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
3732 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
3733 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
3734 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
3735 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
3736 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
3737 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
3738 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3739 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3740 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3741 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
3742 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
3743 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3744 }
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
3745
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3746 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3747 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
3748 debugger_repl(root);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3749 return context;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3750 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3751
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3752 #endif
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3753
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
3754 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
3755 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3756 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3757 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3758 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
3759
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
3760 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
3761
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
3762 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
3763 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3764 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3765 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3766 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3767 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
3768 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
3769 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
3770 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3771 //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
3772 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
3773 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
3774 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
3775 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
3776 remove_breakpoint(context, root->branch_f);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3777 }
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
3778 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
3779 } 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
3780 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
3781 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
3782 remove_breakpoint(context, root->branch_t);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3783 }
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
3784 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
3785 }
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
3786
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3787 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
3788 int debugging = 1;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3789 //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
3790 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
3791 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3792 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3793 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3794 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3795 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3796 return;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3797 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3798 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3799 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
3800 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3801 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3802 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3803 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3804 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
3805 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3806 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
3807 }
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3808 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
3809 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
3810 } 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
3811 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
3812 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3813 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3814 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3815 }
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3816 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
3817 root->after = after;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3818 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
3819 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
3820 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
3821 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3822 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3823 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3824 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
3825 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
3826 }
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
3827 }
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3828 m68k_disasm_labels(&inst, input_buf, root->disasm);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3829 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
3830 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
3831 return;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3832 }