Mercurial > repos > blastem

annotate debug.c @ 2357:344c6a3fe8a8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix annoying bug in debugger tokenizer
author Michael Pavone <pavone@retrodev.com>
date Fri, 27 Oct 2023 23:49:04 -0700
parents 0343f0d5add0
children 4b2ac43c106e
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;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
170 while (**end && !isspace(**end))
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
171 {
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
172 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
173 switch (**end)
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
174 {
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
175 case '+':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
176 case '-':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
177 case '*':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
178 case '/':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
179 case '&':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
180 case '|':
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
181 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 '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
185 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
186 case '<':
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
187 case '.':
2357
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
188 case '[':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
189 case ']':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
190 case '(':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents: 2302
diff changeset
191 case ')':
2172
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
192 done = 1;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
193 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
194 }
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
195 if (done) {
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
196 break;
a00773a336d8 Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents: 2171
diff changeset
197 }
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
198
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
199 ++*end;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
200 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
201 char *name = malloc(*end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
202 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
203 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
204 return (token) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
205 .type = TOKEN_NAME,
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
206 .v = {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
207 .str = name
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
208 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
209 };
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 static void free_expr(expr *e)
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 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
215 return;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
216 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
217 free_expr(e->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
218 free_expr(e->right);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
219 if (e->op.type == TOKEN_NAME) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
220 free(e->op.v.str);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
221 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
222 free(e);
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
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
225 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
226 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
227
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
228 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
229 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
230 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
231 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
232 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
233 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
234 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
235 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
236 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
237 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
238 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
239 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
240 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
241 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
242 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
243 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
244 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
245 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
246 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
247 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
248 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
249 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
250 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
251 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
252 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
253 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
254 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
255 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
256 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
257 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
258 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
259 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
260 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
261 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
262 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
263 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
264 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
265 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
266 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
267 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
268 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
269 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
270 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
271 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
272 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
273 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
274 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
275 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
276 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
277 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
278 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
279 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
280 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
281 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
282 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
283 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
284 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
285 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
286 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
287 return ret;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
288 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
289 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
290 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
291 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
292 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
293 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
294 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
295 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
296 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
297 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
298 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
299 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
300 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
301 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
302 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
303 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
304 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
305 ret->left->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
306 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
307 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
308 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
309
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
310 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
311 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
312 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
313 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
314 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
315 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
316 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
317 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
318 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
319 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
320 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
321 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
322 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
323 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
324 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
325 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
326 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
327 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
328 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
329 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
330 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
331 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
332 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
333 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
334 return maybe_binary(bin, *end, end);
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 '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
337 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
338 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
339 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
340 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
341 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
342 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
343 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
344 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
345 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
346 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
347
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
348 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
349 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
350 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
351 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
352 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
353 *end = start;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
354 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
355 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
356 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
357 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
358 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
359 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
360 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
361 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
362 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
363 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
364 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
365 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
366 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
367 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
368 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
369 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
370 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
371 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
372 return left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
373 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
374 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
375
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
376 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
377 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
378 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
379 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
380 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
381 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
382 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
383 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
384 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
385 return NULL;
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 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
388 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
389 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
390 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
391 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
392 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
393 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
394 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
395 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
396 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
397 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
398 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
399 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
400 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
401 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
402 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
403 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
404 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
405 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
406 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
407 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
408 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
409 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
410 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
411 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
412 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
413 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
414 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
415 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
416 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
417 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
418 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
419 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
420 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
421 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
422 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
423 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
424 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
425 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
426 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
427 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
428 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
429 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
430 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
431 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
432 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
433 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
434 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
435 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
436 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
437 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
438 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
439 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
440 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
441 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
442 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
443 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
444 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
445 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
446 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
447 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
448 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
449 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
450 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
451 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
452 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
453 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
454 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
455 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
456 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
457 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
458 return maybe_muldiv(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
459 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
460 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
461 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
462 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
463 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
464 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
465 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
466 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
467 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
468 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
469 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
470 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
471 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
472 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
473 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
474 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
475 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
476 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
477 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
478 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
479 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
480 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
481 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
482 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
483 } else {
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
484 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
485 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
486 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
487 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
488 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
489 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
490 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
491
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
492 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
493 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
494 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
495 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
496 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
497 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
498 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
499 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
500 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
501 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
502 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
503 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
504 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
505 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
506 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
507 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
508 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
509 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
510 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
511 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
512 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
513 return ret;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
514 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
515 if (first.type == TOKEN_LBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
516 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
517 ret->type = EXPR_MEM;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
518 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
519 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
520 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
521 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
522 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
523 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
524 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
525 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
526 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
527 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
528 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
529 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
530 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
531 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
532 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
533 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
534 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
535 }
2171
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
536 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
537 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
538 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
539 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
540 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
541 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
542 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
543 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
544 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
545 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
546 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
547 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
548 return NULL;
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
549 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
550 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
551 }
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
552 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) {
4b47155965c8 Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents: 2170
diff changeset
553 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
554 return NULL;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
555 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
556 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
557 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
558 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
559 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
560 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
561 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
562 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
563 bin->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
564 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
565 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
566 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
567 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
568 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
569 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
570 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
571 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
572 bin->right = parse_scalar(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
573 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
574 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
575 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
576 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
577 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
578 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
579 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
580 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
581 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
582 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
583 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
584 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
585 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
586 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
587 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
588 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
589 case '!':
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
590 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
591 case '<':
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
592 bin->right = parse_expression(after_second, end);
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
593 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
594 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
595 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
596 return NULL;
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
597 }
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
598 return bin;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
599 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
600 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
601 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
602 free(bin);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
603 return NULL;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
604 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
605 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
606 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
607 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
608 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
609 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
610 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
611 value->left->op = first;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
612 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
613 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
614 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
615 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
616 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
617 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
618 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
619 ret->op = first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
620 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
621 return ret;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
622 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
623 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
624
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
625 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
626 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
627 uint32_t right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
628 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
629 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
630 case EXPR_SCALAR:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
631 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
632 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
633 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
634 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
635 tern_val v;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
636 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
637 *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
638 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
639 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
640 return 0;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
641 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
642 *out = e->op.v.num;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
643 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
644 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
645 case EXPR_UNARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
646 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
647 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
648 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
649 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
650 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
651 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
652 *out = !*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
653 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
654 case '~':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
655 *out = ~*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
656 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
657 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
658 *out = -*out;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
659 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
660 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
661 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
662 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
663 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
664 case EXPR_BINARY:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
665 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
666 return 0;
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 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
669 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
670 case '+':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
671 *out += right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
672 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
673 case '-':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
674 *out -= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
675 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
676 case '*':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
677 *out *= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
678 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
679 case '/':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
680 *out /= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
681 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
682 case '&':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
683 *out &= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
684 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
685 case '|':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
686 *out |= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
687 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
688 case '^':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
689 *out ^= right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
690 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
691 case '=':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
692 *out = *out == right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
693 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
694 case '!':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
695 *out = *out != right;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
696 break;
2191
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
697 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
698 *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
699 break;
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
700 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents: 2190
diff changeset
701 *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
702 break;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
703 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
704 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
705 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
706 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
707 case EXPR_SIZE:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
708 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
709 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
710 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
711 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
712 {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
713 case 'b':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
714 *out &= 0xFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
715 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
716 case 'w':
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
717 *out &= 0xFFFF;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
718 break;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
719 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
720 return 1;
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
721 case EXPR_MEM:
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
722 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
723 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
724 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
725 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
726 default:
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
727 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
728 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
729 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
730
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
731 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
732 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
733 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
734 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
735 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
736 return buf+1;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
737 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
738 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
739 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
740 return NULL;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
741 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
742
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
743 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
744 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
745 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
746 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
747 *buf = 0;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
748 return;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
749 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
750 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
751 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
752
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
753 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
754 {
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
755 //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
756 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
757 }
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
758
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
759 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
760 {
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
761 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
762 }
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
763
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
764 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
765 {
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
766 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
767 }
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
768
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
769 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
770 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
771 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
772 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
773 *out = m68k_read_byte(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
774 } else if (size == 'l') {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
775 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
776 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
777 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
778 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
779 *out = m68k_read_long(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
780 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
781 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
782 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
783 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
784 }
2170
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
785 *out = m68k_read_word(*out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
786 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
787 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
788 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents: 2169
diff changeset
789
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
790 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
791 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
792 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
793 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
794 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
795 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
796 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
797 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
798 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
799 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
800 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
801 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
802 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
803 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
804 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
805 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
806 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
807 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
808 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
809 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
810 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
811
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
812 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
813 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
814 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
815 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
816 *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
817 } 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
818 *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
819 } else if (!strcasecmp(name, "sr")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
820 *out = context->status << 8;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
821 for (int flag = 0; flag < 5; flag++) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
822 *out |= context->flags[flag] << (4-flag);
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
823 }
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
824 } else if(!strcasecmp(name, "cycle")) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
825 *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
826 } else if (!strcasecmp(name, "pc")) {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
827 *out = root->address;
2174
eff7bedfc838 Restore ability to print PC in debugger. Make 68K register names case insensitive. Add usp and ssp registers
Michael Pavone <pavone@retrodev.com>
parents: 2173
diff changeset
828 } 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
829 *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
830 } 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
831 *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
832 } else {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
833 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
834 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
835 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
836 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
837
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
838 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
839 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
840 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
841 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
842 context->dregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
843 } 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
844 context->aregs[name[1]-'0'] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
845 } else if (!strcasecmp(name, "sr")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
846 context->status = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
847 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
848 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
849 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
850 } else if (!strcasecmp(name, "usp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
851 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
852 } else if (!strcasecmp(name, "ssp")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
853 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
854 } else {
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 return 1;
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
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
860 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
861 {
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
862 if (resolve_m68k(root, name, out)) {
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
863 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
864 }
2175
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
865 m68k_context *m68k = root->cpu_context;
8c28c5466d70 Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents: 2174
diff changeset
866 genesis_context *gen = m68k->system;
2169
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
867 if (!strcmp(name, "f") || !strcmp(name, "frame")) {
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
868 *out = gen->vdp->frame;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
869 return 1;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
870 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
871 return 0;
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
872 }
cb9572145f8e WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2133
diff changeset
873
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
874 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
875 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
876 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
877 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
878 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
879 free(full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
880 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
881
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
882 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
883 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
884 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
885 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
886 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
887 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
888 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
889 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
890 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
891 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
892 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
893 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
894 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
895 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
896 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
897 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
898 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
899 if (node->left || node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
900 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
901 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
902 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
903 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
904 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
905 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
906 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
907 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
908 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
909 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
910 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
911 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
912 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
913 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
914 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
915 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
916 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
917 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
918 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
919 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
920 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
921 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
922 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
923 while (*cur && !isspace(*cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
924 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
925 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
926 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
927 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
928 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
929 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
930 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
931 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
932 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
933 if (*cur && *cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
934 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
935 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
936 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
937 if (def->raw_args) {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
938 while (*cur && *cur != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
939 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
940 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
941 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
942 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
943 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
944 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
945 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
946 raw_param[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
947 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
948 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
949 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
950 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
951 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
952 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
953 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
954 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
955 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
956 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
957 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
958 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
959 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
960 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
961 while (*text && *text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
962 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
963 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
964 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
965 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
966 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
967 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
968 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
969 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
970 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
971 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
972 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
973 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
974 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
975 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
976 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
977 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
978 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
979 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
980 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
981 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
982 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
983 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
984 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
985 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
986 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
987 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
988 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
989 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
990 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
991 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
992 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
993 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
994 out->format = format;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
995
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
996 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
997 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
998 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
999 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
1000 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1001 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1002 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1003 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1004 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
1005 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1006 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1007 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1008 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1009 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1010
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
1011 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
1012 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
1013 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1014 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
1015 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1016 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
1017 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1018 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
1019 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1020
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1021 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
1022 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1023 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1024 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1025 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
1026 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1027 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1028 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1029 }
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
1030 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
1031 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
1032 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1033 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1034
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
1035 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
1036 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
1037 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
1038 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
1039 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
1040 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
1041 };
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1042
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1043 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
1044 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1045 ++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
1046 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
1047 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1048 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
1049 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1050 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
1051 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
1052 #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
1053 #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
1054 #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
1055 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
1056 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
1057 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
1058 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
1059 #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
1060 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
1061 process_events();
2302
0343f0d5add0 Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents: 2252
diff changeset
1062 #ifndef IS_LIB
2252
6a07b13894f7 Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2216
diff changeset
1063 render_update_display();
2302
0343f0d5add0 Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents: 2252
diff changeset
1064 #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
1065 #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
1066 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
1067 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
1068 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
1069 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
1070 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
1071 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1072 #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
1073 } 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
1074
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1075 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
1076 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
1077 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
1078 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
1079 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1080 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
1081 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
1082 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
1083 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1084 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
1085 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
1086 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
1087 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1088 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
1089 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
1090 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1091 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1092 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
1093 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
1094 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
1095 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1096 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
1097 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
1098 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
1099 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
1100 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
1101 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1102 if (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
1103 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
1104 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
1105 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1106 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
1107 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1108 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
1109 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
1110 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
1111 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
1112 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
1113 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
1114 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
1115 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
1116 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
1117 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
1118 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
1119 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1120 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
1121 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
1122 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
1123 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1124 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
1125 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
1126 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
1127 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
1128 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1129 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1130 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1131 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
1132 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1133
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1134 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
1135 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1136 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
1137 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
1138 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1139 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
1140 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
1141 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
1142 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1143 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1144 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1145 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
1146 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1147
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1148 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
1149 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1150
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1151 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
1152 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
1153 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
1154 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
1155 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
1156 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
1157 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
1158 }
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
1159 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
1160 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
1161 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1162 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
1163 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
1164 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
1165 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
1166 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
1167 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
1168 }
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1169 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
1170 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
1171 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
1172 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
1173 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
1174 }
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
1175 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
1176 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1177 }
2193
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1178 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
1179 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
1180 } else {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1181 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
1182 }
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents: 2191
diff changeset
1183 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
1184 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1185
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1186 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
1187 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1188 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1189 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1190
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1191 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1192 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1193 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1194 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1195
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1196 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
1197 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1198 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1199 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1200 return;
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 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1203 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1204 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1205 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1206 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1207 state->longest_command = len;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1208 }
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1211 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
1212 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1213 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1214 def->visited = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1215 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1216
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1217 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
1218 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1219 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1220 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1221 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1222 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1223 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1224 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1225 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1226 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1227 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1228 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1229 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1230 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1231 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
1232 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1233 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1234 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1235 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1236 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1237 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1238 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
1239 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1240 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1241 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1242 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1243 split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1244 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1245 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1246 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
1247 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1248 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1249 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1250 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1251 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1252 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1253 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1254 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1255 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1256 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1257 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1258 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1259 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1260 putchar(',');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1261 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1262 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
1263 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1264 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1265 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1266 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1267 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1268 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1269 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1270 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1271 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1272 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1273 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1274 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
1275 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1276 fputs(extra_desc, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1277 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1278 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1279 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1280
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
1281 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
1282 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1283 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1284 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
1285 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
1286 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
1287 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
1288 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1289 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1290
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
1291 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
1292 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1293 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1294 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1295
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
1296 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
1297 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1298 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1299 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1300 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1301 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1302 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1303 case 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1304 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1305 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1306 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1307 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1308 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1309 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1310 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
1311 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1312 }
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
1313 }
e17d99c96c89 Make blocks an 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
e17d99c96c89 Make blocks an 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 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
1316 {
e17d99c96c89 Make blocks an 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 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
1318 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
1319 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
1320 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
1321 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
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 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
1324 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
1325 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
1326 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
1327 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
1328 }
e17d99c96c89 Make blocks an 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 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
1330 }
e17d99c96c89 Make blocks an 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 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
1332 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
1333 } 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
1334 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
1335 }
e17d99c96c89 Make blocks an 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
e17d99c96c89 Make blocks an 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 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
1339 {
e17d99c96c89 Make blocks an 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 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
1341 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
1342 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
1343 {
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
1344 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
1345 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1346 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1347 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1348
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
1349 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
1350 {
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
1351 char *param = cmd->raw;
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1352 if (!param) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1353 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
1354 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1355 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1356 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1357 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1358 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1359 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1360 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1361 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
1362 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1363 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1364 ++param;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1365 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1366 char *cur = param, *out = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1367 while (*cur && *cur != '"')
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1368 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1369 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1370 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1371 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1372 case 't':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1373 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1374 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1375 case 'n':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1376 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1377 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1378 case 'r':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1379 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1380 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1381 case '\\':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1382 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1383 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1384 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1385 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
1386 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1387 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1388 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1389 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1390 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1391 *(out++) = *(cur++);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1392 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1393 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1394 *out = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1395 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1396 param = cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1397 cur = fmt;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1398 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1399 while (*cur)
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1400 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1401 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1402 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1403 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1404 case 'x':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1405 case 'X':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1406 case 'c':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1407 case 'd':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1408 case 's':
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1409 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1410 default:
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1411 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
1412 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1413 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1414 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1415 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1416 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1417 if (!arg) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1418 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1419 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1420 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1421 uint32_t val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1422 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1423 free(fmt);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1424 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1425 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1426 if (cur[1] == 's') {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1427 char tmp[128];
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1428 int j;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1429 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
1430 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1431 uint32_t addr = val;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1432 root->read_mem(root, &addr, 'b');
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1433 char c = addr;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1434 if (c < 0x20 || c > 0x7F) {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1435 break;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1436 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1437 tmp[j] = c;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1438 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1439 tmp[j] = 0;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1440 printf(format_str, tmp);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1441 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1442 printf(format_str, val);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1443 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1444 cur += 2;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1445 } else {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1446 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1447 ++cur;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1448 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1449 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1450 return 1;
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1451 }
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
1452
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
1453 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
1454 {
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
1455 cmd_print(root, cmd);
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1456 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
1457 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1458 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
1459 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
1460 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
1461 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
1462 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
1463 cmd->num_args = 0;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1464 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1465 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
1466 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1467 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1468
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
1469 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
1470 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1471 disp_def **cur = &root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1472 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1473 {
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
1474 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
1475 disp_def *del_disp = *cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1476 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1477 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1478 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
1479 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1480 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1481 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
1482 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1483 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1484 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1485 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1486 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1487 cur = &(*cur)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1488 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1489 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1490 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1491 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1492
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
1493 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
1494 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1495 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1496 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1497 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1498 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1499 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
1500 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1501 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1502 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1503
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
1504 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
1505 {
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
1506 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
1507 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
1508 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
1509 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1510 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1511 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
1512 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1513 free_parsed_command((*target)->commands + i);
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 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
1516 (*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
1517 (*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
1518 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
1519 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
1520 return 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1521 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1522
2190
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1523 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
1524 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1525 uint8_t debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1526 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
1527 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1528 debugging = run_command(root, block->commands + i) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1529 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1530 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1531 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1532
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1533 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
1534 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1535 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
1536 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1537
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1538 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
1539 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1540 if (!cmd->args[0].value) {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1541 return execute_block(root, &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1542 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1543 int debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1544 do {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1545 debugging = execute_block(root, &cmd->block) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1546 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
1547 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
1548 return 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1549 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1550 } while (cmd->args[0].value);
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1551 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1552 }
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
1553
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1554 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1555 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1556 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1557 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1558 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1559 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1560 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1561 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1562
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
1563 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
1564 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1565 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1566 char size = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1567 uint32_t address;
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1568 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
1569 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1570 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
1571 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
1572 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
1573 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1574 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
1575 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1576 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1577 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1578 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
1579 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
1580 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
1581 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
1582 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1583 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
1584 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1585 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1586 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1587 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
1588 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
1589 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
1590 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
1591 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1592 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1593 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1594 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
1595 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
1596 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1597 }
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1598 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
1599 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
1600 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1601 }
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
1602 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
1603 if (name && size && size != 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1604 uint32_t old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1605 if (!root->resolve(root, name, &old)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1606 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
1607 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1608 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1609 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1610 old &= 0xFFFFFF00;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1611 value &= 0xFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1612 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
1613 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1614 old &= 0xFFFF0000;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1615 value &= 0xFFFF;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1616 value |= old;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1617 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1618 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1619 if (name) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1620 if (!root->set(root, name, value)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1621 fprintf(stderr, "Failed to set %s\n", name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1622 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1623 } 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
1624 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
1625 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1626 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1627 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1628
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1629 static uint8_t cmd_frames(debug_root *root, parsed_command *cmd)
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1630 {
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1631 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
1632 return 0;
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1633 }
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
1634
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1635 static uint8_t cmd_bindup(debug_root *root, parsed_command *cmd)
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1636 {
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
1637 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
1638 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
1639 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1640 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1641 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1642
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
1643 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
1644 {
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
1645 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
1646 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
1647 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1648 return 1;
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1649 }
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
1650
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
1651 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
1652 {
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
1653 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
1654 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
1655 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1656 }
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
1657 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
1658 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
1659 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
1660 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1661 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1662 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
1663 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
1664 (*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
1665 cmd->args[1].parsed = NULL;
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1666 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1667 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1668 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1669 return 1;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1670 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
1671
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1672 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
1673 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1674 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
1675 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
1676 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
1677 *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
1678 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1679 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1680
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1681 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
1682 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1683 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
1684 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
1685 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
1686 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
1687 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1688 putchar(' ');
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1689 len++;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1690 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1691 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
1692 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1693
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1694 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
1695 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1696 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
1697 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
1698 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
1699 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
1700 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
1701 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
1702 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1703 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
1704 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
1705 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1706 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
1707 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
1708 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
1709 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
1710 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
1711 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
1712 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
1713 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
1714 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
1715 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1716 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1717 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1718 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1719 } else {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1720 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
1721 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
1722 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
1723 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
1724 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1725 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
1726 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
1727
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
1728 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
1729 {
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
1730 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
1731 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
1732 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
1733 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1734 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1735 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1736 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
1737 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1738 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1739 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
1740 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1741 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1742 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1743 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1744 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1745 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1746 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1747 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1748
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
1749 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
1750 {
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
1751 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
1752 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
1753 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
1754 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
1755 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1756 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
1757 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
1758 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1759 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1760
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
1761 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
1762 {
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
1763 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
1764 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1765 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1766
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
1767 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
1768 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1769 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1770 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1771 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1772 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1773 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
1774 } 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
1775 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
1776 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1777 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
1778 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1779 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
1780 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
1781 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1782 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1783 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
1784 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
1785 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1786 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1787 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1788 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
1789 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
1790 }
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 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
1793 }
2178
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 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
1796 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1797 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1798
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
1799 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
1800 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1801 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1802 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1803 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1804 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1805 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
1806 } 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
1807 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
1808 } 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
1809 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
1810 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
1811 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1812 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1813 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1814 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1815 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
1816 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1817 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1818 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
1819 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1820 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1821 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1822 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1823 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1824 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1825 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
1826 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1827 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1828 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1829 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
1830 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1831 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1832 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
1833 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1834 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1835
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
1836 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
1837 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1838 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1839 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1840 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1841 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1842 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
1843 } 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
1844 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
1845 } 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
1846 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
1847 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1848 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
1849 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
1850 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1851 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1852 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
1853 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
1854 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1855 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1856 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1857 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
1858 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
1859 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1860 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1861 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
1862 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1863 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1864 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
1865 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1866 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1867
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
1868 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
1869 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1870 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1871 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1872 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1873 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1874 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
1875 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
1876 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1877 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1878 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1879 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1880 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1881 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
1882 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1883 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
1884 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1885 //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
1886 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1887 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1888 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1889 //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
1890 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1891 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1892 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1893
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1894 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
1895 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1896 m68k_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1897 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1898 if (cmd->num_args) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1899 address = cmd->args[0].value;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1900 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1901 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1902 m68kinst inst;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1903 do {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1904 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1905 if (def) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1906 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
1907 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1908 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1909 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1910 }
2252
6a07b13894f7 Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents: 2216
diff changeset
1911
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1912 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1913 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1914 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1915 } while(!m68k_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1916 return 1;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1917 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
1918
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
1919 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
1920 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1921 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1922 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1923 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1924 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1925 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1926
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
1927 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
1928 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1929 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1930 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1931 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1932 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1933 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1934
2188
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents: 2187
diff changeset
1935 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
1936 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1937 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1938 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
1939 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
1940 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
1941 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1942 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
1943 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
1944 }
2173
894c7873a2b1 Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents: 2172
diff changeset
1945 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1946 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1947 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1948
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
1949 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
1950 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1951 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1952 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1953 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1954 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1955 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
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_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
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 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1960 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1961 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1962 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1963 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1964 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1965 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1966 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1967 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
1968 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1969 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
1970 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1971 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
1972 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1973 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1974 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
1975 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1976 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1977 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
1978 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1979 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1980 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1981 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1982 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1983 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1984 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1985
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
1986 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
1987 {
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
1988 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1989 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1990 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1991 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1992 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1993 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1994 segacd_context *cd = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
1995
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1996 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
1997 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
1998 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
1999 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2000 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
2001 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2002 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2003 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
2004 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2005 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2006 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
2007 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2008 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2009 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2010 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2011 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2012 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2013 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2014
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
2015 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
2016 {
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
2017 char *param = cmd->raw;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2018 while (param && *param && isblank(*param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2019 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2020 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2021 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2022 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2023 genesis_context *gen = m68k->system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2024
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2025 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
2026 parsed_command cmd = {0};
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2027 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
2028 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2029 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
2030 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2031 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2032 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
2033 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2034 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2035 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
2036 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2037 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2038 } else {
2184
408fb8a7e990 Implement argumentless variant of z80 debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2183
diff changeset
2039 gen->enter_z80_debugger = 1;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2040 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2041 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2042 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2043
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2044 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2045 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2046 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2047 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2048 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2049 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2050 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2051 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2052 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2053 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2054 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2055 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2056 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2057 "help", "?", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2058 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2059 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2060 .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
2061 .impl = cmd_help,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2062 .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
2063 .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
2064 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2065 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2066 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2067 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2068 "continue", "c", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2069 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2070 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2071 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2072 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2073 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2074 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2077 .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
2078 "print", "p", NULL
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2079 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2080 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2081 .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
2082 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2083 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2084 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2085 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2086 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2087 .names = (const char *[]){
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2088 "printf", NULL
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2089 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2090 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2091 .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
2092 .impl = cmd_printf,
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2093 .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
2094 .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
2095 .raw_args = 1
2187
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2096 },
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2097 {
d0129f19ca52 Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents: 2186
diff changeset
2098 .names = (const char *[]){
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2099 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2100 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2101 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2102 .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
2103 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2104 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2105 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2106 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2107 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2108 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2109 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2110 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2111 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2112 .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
2113 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2114 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2115 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2116 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2117 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2118 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2119 "deletedisplay", "dd", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2120 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2121 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2122 .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
2123 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2124 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2125 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2126 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2127 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2128 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2129 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2130 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2131 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2132 .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
2133 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2134 .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
2135 .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
2136 .has_block = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2137 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2138 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2139 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2140 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2141 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2142 .usage = "set MEM|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2143 .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
2144 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2145 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2146 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2147 .skip_eval = 1
2179
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2148 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2149 {
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2150 .names = (const char *[]){
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2151 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2152 },
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2153 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2154 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2155 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2156 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents: 2178
diff changeset
2157 .max_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2158 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2159 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2160 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2161 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2162 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2163 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2164 .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
2165 .impl = cmd_bindup,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2166 .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
2167 .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
2168 .raw_args = 1
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2169 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2170 {
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2171 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2172 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2173 },
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2174 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2175 .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
2176 .impl = cmd_binddown,
2181
0c723b8b637c Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2180
diff changeset
2177 .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
2178 .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
2179 .raw_args = 1
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2180 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2181 {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2182 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2183 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2184 },
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2185 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2186 .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
2187 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
2188 .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
2189 .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
2190 .skip_eval = 1
2190
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2191 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2192 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2193 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2194 "if", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2195 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2196 .usage = "if CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2197 .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
2198 .impl = cmd_if,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2199 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2200 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2201 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2202 .accepts_else = 1
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2203 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2204 {
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2205 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2206 "while", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2207 },
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2208 .usage = "while CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2209 .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
2210 .impl = cmd_while,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2211 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2212 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2213 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents: 2189
diff changeset
2214 .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
2215 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2216 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2217 .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
2218 "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
2219 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2220 .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
2221 .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
2222 .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
2223 .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
2224 .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
2225 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2226 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2227 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2228 #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
2229
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2230 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2231 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2232 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2233 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2234 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2235 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2236 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2237 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2238 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2239 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2240 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2241 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2242 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2243 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2244 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2245 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2246 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2247 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2248 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2249 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2250 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2251 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2252 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2253 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2254 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2255 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2256 .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
2257 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2258 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2259 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2260 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2263 "over", NULL
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 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2266 .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
2267 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2268 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2269 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2270 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2271 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2272 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2273 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2274 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2275 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2276 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2277 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2278 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2279 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2280 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2281 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2282 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2283 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2284 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2285 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2286 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2287 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2288 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2289 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2290 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2293 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2294 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2295 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2296 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2297 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2298 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2299 .max_args = 1
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2300 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2301 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2302 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2303 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2304 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2305 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2306 .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
2307 .impl = cmd_disassemble_m68k,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2308 .min_args = 0,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2309 .max_args = 1
2112
3abb64bd0da6 Add support for printing strings in 68K debugger
Michael Pavone <pavone@retrodev.com>
parents: 2107
diff changeset
2310 }
2178
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 #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
2314
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2315 command_def genesis_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2316 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2317 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2318 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2319 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2320 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2321 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2322 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2323 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2324 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2325 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2326 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2327 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2328 "vdpsregs", "vr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2329 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2330 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2331 .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
2332 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2333 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2334 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2335 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2336 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2337 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2338 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2339 "z80", NULL
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 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2342 .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
2343 .impl = cmd_gen_z80,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2344 .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
2345 .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
2346 .raw_args = 1
2178
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 #endif
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2351 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2352 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2353 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2354 .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
2355 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2356 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2357 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2358 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2361 "ymtimer", "yt", NULL
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 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2364 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2365 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2366 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2367 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2368 }
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 #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
2372
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2373 command_def scd_main_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2374 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2375 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2376 "subcpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2377 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2378 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2379 .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
2380 .impl = cmd_sub,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2381 .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
2382 .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
2383 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2384 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2385 };
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 #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
2388
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2389 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2390 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2391 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2392 "maincpu", NULL
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 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2395 .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
2396 .impl = cmd_main,
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2397 .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
2398 .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
2399 .raw_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2400 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2401 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2402
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2403 #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
2404
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2405 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2406
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
2407 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
2408 {
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
2409 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
2410 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
2411 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
2412 return 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 bp_def *tmp = *this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2415 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
2416 *this_bp = (*this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2417 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2418 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
2419 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2420 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2421 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2422 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2423 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2424 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2425 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2426 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2427
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
2428 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
2429 {
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
2430 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
2431 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
2432 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
2433 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
2434 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2435 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
2436 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
2437 return 1;
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
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
2440 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
2441 {
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
2442 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
2443 return 0;
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
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
2446 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
2447 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2448 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2449 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2450 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2451 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2452 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
2453 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2454 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2455 } 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
2456 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2457 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
2458 } 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
2459 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
2460 } 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
2461 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
2462 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2463 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2464 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2465 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2466 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2467 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
2468 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2469 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2470 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
2471 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2472 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2473 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2474 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2475 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2476 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
2477 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2478 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2479
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
2480 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
2481 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2482 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2483 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2484 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2485
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
2486 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
2487 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2488 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2489 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2490 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2491 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2492 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2493 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2494 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2495 } 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
2496 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2497 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
2498 } 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
2499 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
2500 } 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
2501 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
2502 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2503 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2504 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2505 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2506 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2507 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
2508 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2509 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2510 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
2511 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2512 after |= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2513 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2514 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2515 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2516 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
2517 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2518 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2519
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
2520 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
2521 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2522 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2523 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2524 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2525 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2526 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2527 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
2528 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2529 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2530 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
2531 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2532 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2533 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2534 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2535 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2536 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
2537 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2538 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2539 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
2540 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2541 //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
2542 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2543 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2544 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2545 //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
2546 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2547 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2548 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2549
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2550 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
2551 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2552 z80_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2553 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2554 if (cmd->num_args) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2555 address = cmd->args[0].value;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2556 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2557 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2558 z80inst inst;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2559 do {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2560 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2561 if (def) {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2562 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
2563 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2564 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2565 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2566 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2567 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
2568 uint8_t *after = z80_decode(pc, &inst);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2569 z80_disasm(&inst, disasm_buf, address);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2570 address += after - pc;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2571 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2572 } while(!z80_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2573 return 1;
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2574 }
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2575
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
2576 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
2577 {
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
2578 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
2579 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
2580 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2581 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2582 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2583 genesis_context *gen = (genesis_context *)current_system;
2186
935e684f2d58 Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents: 2185
diff changeset
2584
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2585 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
2586 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
2587 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
2588 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
2589 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
2590 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2591 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2592 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
2593 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2594 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2595 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
2596 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
2597 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2598 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2599 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
2600 return 0;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2601 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2602 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2603
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2604 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
2605 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2606 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
2607 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
2608 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
2609 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2610 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2611
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2612 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
2613 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2614 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
2615 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
2616 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
2617 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2618 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2619
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2620 command_def z80_commands[] = {
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2623 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2624 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2625 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2626 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2627 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2628 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2629 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2630 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2633 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2634 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2635 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2636 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2637 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2638 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2639 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2640 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2643 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2644 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2645 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2646 .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
2647 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2648 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2649 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2650 },
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2653 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2654 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2655 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2656 .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
2657 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2658 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2659 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2660 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2661 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2662 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2663 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2664 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2665 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2666 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2667 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2668 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2669 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2670 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2671 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2672 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2673 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2674 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2675 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2676 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2677 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2678 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2679 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2682 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2683 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2684 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2685 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2686 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2687 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2688 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2689 .max_args = 1
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2690 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2691 {
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2692 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2693 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2694 },
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2695 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2696 .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
2697 .impl = cmd_disassemble_z80,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2698 .min_args = 0,
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
2699 .max_args = 1
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2700 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2701 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2702
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2703 #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
2704
2185
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2705 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
2706 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2707 .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
2708 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2709 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2710 .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
2711 .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
2712 .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
2713 .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
2714 .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
2715 .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
2716 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2717 };
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2718
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents: 2184
diff changeset
2719 #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
2720
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2721 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
2722 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2723 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2724 "vdpsprites", "vs", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2725 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2726 .usage = "vdpsprites",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2727 .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
2728 .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
2729 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2730 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2731 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2732 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2733 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2734 "vdpsregs", "vr", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2735 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2736 .usage = "vdpregs",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2737 .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
2738 .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
2739 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2740 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2741 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2742 };
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2743
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
2744 #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
2745
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2746 #endif
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 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
2749 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2750 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
2751 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2752 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
2753 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2754 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
2755 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2756 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2757 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2758
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2759 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
2760 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2761 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
2762 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
2763 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
2764 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2765 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
2766 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2767 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2768
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2769 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
2770 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2771 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2772 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2773 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
2774 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
2775 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2776 root->write_mem = write_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2777 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
2778 root->disasm = create_68000_disasm();
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2779 switch (current_system->type)
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 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2782 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2783 //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
2784 if (context->system == current_system) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2785 root->resolve = resolve_genesis;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2786 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
2787 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
2788 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
2789 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
2790 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2791 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2792 } 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
2793 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
2794 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
2795 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2796 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2797 root->resolve = resolve_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2798 }
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
2799 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
2800 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2801 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
2802 }
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
2803
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
2804 #ifndef NO_Z80
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
2805
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2806 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
2807 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2808 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2809 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2810 *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
2811 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2812 *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
2813 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2814 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2815 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2816
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2817 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
2818 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2819 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2820 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
2821 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2822 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
2823 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2824 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2825 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2826
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2827 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
2828 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2829 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2830 switch (tolower(name[0]))
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2831 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2832 case 'a':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2833 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2834 *out = context->regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2835 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2836 *out = context->alt_regs[Z80_A];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2837 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2838 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2839 *out = context->regs[Z80_A] << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2840 *out |= context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2841 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2842 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2843 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2844 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2845 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2846 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2847 *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
2848 *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
2849 *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
2850 *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
2851 *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
2852 *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
2853 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2854 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2855 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2856 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2857 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2858 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2859 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2860 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2861 case 'b':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2862 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2863 *out = context->regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2864 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2865 *out = context->alt_regs[Z80_B];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2866 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2867 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2868 *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
2869 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2870 *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
2871 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2872 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2873 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2874 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2875 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2876 case 'c':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2877 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2878 *out = context->regs[Z80_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2879 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2880 *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
2881 } 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
2882 *out = context->current_cycle;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2883 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2884 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2885 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2886 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2887 case 'd':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2888 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2889 *out = context->regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2890 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2891 *out = context->alt_regs[Z80_D];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2892 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2893 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2894 *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
2895 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2896 *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
2897 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2898 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2899 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2900 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2901 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2902 case 'e':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2903 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2904 *out = context->regs[Z80_E];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2905 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2906 *out = context->alt_regs[Z80_E];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2907 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2908 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2909 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2910 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2911 case 'f':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2912 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2913 *out = context->flags[ZF_S] << 7;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2914 *out |= context->flags[ZF_Z] << 6;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2915 *out |= context->flags[ZF_H] << 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2916 *out |= context->flags[ZF_PV] << 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2917 *out |= context->flags[ZF_N] << 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2918 *out |= context->flags[ZF_C];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2919 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2920 *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
2921 *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
2922 *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
2923 *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
2924 *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
2925 *out |= context->alt_flags[ZF_C];
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2926 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2927 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2928 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2929 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2930 case 'h':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2931 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2932 *out = context->regs[Z80_H];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2933 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2934 *out = context->alt_regs[Z80_H];
2208
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
2935 } 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
2936 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2937 *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
2938 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2939 *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
2940 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2941 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2942 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2943 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2944 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2945 case 'i':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2946 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2947 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2948 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2949 *out = context->regs[Z80_I];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2950 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2951 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2952 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
2953 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2954 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2955 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2956 *out = context->iff1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2957 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2958 *out = context->iff2;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2959 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2960 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2961 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2962 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2963 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2964 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2965 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2966 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2967 *out = context->im;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2968 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2969 case 'n':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2970 if (strcasecmp(name +2, "t_cycle")) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2971 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2972 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2973 *out = context->int_cycle;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2974 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2975 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2976 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2977 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2978 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2979 *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
2980 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2981 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2982 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2983 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2984 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2985 *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
2986 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2987 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2988 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2989 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2990 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2991 *out = context->regs[Z80_IXH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2992 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2993 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2994 return 0;
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 *out = context->regs[Z80_IXL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2997 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2998 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
2999 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3000 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3001 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3002 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3003 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3004 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3005 *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
3006 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3007 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3008 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3009 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3010 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3011 *out = context->regs[Z80_IYH];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3012 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3013 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3014 return 0;
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 *out = context->regs[Z80_IYL];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3017 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3018 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3019 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3020 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3021 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3022 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3023 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3024 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3025 case 'l':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3026 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3027 *out = context->regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3028 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3029 *out = context->alt_regs[Z80_L];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3030 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3031 return 0;
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 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3034 case 'p':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3035 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
3036 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3037 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3038 *out = root->address;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3039 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3040 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3041 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3042 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3043 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3044 *out = context->regs[Z80_R];
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3045 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3046 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
3047 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3048 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3049 *out = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3050 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3051 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3052 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3053 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3054 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3055 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3056
2198
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3057 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
3058 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3059 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
3060 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3061 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3062 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
3063 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
3064 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
3065 *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
3066 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3067 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3068 return 0;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3069 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3070
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3071 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
3072 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3073 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3074 switch (tolower(name[0]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3075 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3076 case 'a':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3077 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3078 context->regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3079 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3080 context->alt_regs[Z80_A] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3081 } else if (tolower(name[1]) == 'f') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3082 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3083 context->regs[Z80_A] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3084 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
3085 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
3086 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
3087 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
3088 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
3089 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3090 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3091 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
3092 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
3093 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
3094 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
3095 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
3096 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
3097 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
3098 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3099 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3100 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3101 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3102 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3103 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3104 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3105 case 'b':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3106 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3107 context->regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3108 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3109 context->alt_regs[Z80_B] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3110 } else if (tolower(name[1]) == 'c') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3111 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3112 context->regs[Z80_B] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3113 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3114 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3115 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
3116 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3117 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3118 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3119 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3120 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3121 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3122 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3123 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3124 context->regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3125 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3126 context->alt_regs[Z80_C] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3127 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3128 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3129 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3130 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3131 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3132 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3133 context->regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3134 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3135 context->alt_regs[Z80_D] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3136 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3137 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3138 context->regs[Z80_D] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3139 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3140 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3141 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
3142 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3143 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3144 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3145 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3146 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3147 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3148 case 'e':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3149 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3150 context->regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3151 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3152 context->alt_regs[Z80_E] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3153 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3154 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3155 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3156 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3157 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3158 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3159 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
3160 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
3161 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
3162 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
3163 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
3164 context->flags[ZF_C] = value & 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3165 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3166 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
3167 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
3168 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
3169 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
3170 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
3171 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
3172 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3173 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3174 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3175 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3176 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3177 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3178 context->regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3179 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3180 context->alt_regs[Z80_H] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3181 } else if (tolower(name[1]) == 'e') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3182 if (!name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3183 context->regs[Z80_H] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3184 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3185 } else if (name[2] == '\'' && !name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3186 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
3187 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3188 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3189 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3190 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3191 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3192 break;
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3193 case 'i':
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3194 switch (tolower(name[1]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3195 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3196 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3197 context->regs[Z80_I] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3198 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3199 case 'f':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3200 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
3201 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3202 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3203 if (name[3] == '1') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3204 context->iff1 = value != 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3205 } else if (name[3] == '2') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3206 context->iff2 = value != 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3207 } else {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3208 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3209 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3210 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3211 case 'm':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3212 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3213 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3214 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3215 context->im = value & 3;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3216 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3217 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3218 if (name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3219 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3220 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3221 context->regs[Z80_I] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3222 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3223 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3224 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3225 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3226 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3227 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3228 context->regs[Z80_IXH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3229 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3230 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3231 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3232 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3233 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3234 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3235 context->regs[Z80_IXH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3236 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3237 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3238 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3239 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3240 context->regs[Z80_IXL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3241 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3242 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3243 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3244 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3245 case 'y':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3246 switch (tolower(name[2]))
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3247 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3248 case 0:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3249 context->regs[Z80_IYH] = value >> 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3250 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3251 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3252 case 'h':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3253 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3254 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3255 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3256 context->regs[Z80_IYH] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3257 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3258 if (name[3]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3259 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3260 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3261 context->regs[Z80_IYL] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3262 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3263 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3264 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3265 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3266 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3267 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3268 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3269 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3270 case 'l':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3271 if (!name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3272 context->regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3273 } else if (name[1] == '\'' && !name[2]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3274 context->alt_regs[Z80_L] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3275 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3276 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3277 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3278 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3279 case 'r':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3280 if (name[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3281 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3282 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3283 context->regs[Z80_R] = value;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3284 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3285 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
3286 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3287 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3288 context->sp = value;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3289 break;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3290 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3291 return 0;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3292 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3293 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3294 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3295
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3296 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
3297 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3298 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3299 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3300 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
3301 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
3302 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
3303 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3304 case SYSTEM_GENESIS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3305 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
3306 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
3307 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
3308 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3309 case SYSTEM_SMS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3310 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
3311 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
3312 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3313 default:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents: 2193
diff changeset
3314 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
3315 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3316 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3317 root->write_mem = write_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3318 root->set = set_z80;
2216
4e27c36f947c Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents: 2214
diff changeset
3319 root->disasm = create_z80_disasm();
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3320 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3321 return root;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3322 }
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3323
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3324 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
3325 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3326 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3327 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3328 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
3329 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
3330 init_terminal();
2180
b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor
Michael Pavone <pavone@retrodev.com>
parents: 2179
diff changeset
3331 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
3332 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
3333 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
3334 }
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
3335 root->address = address;
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3336 //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
3337 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
3338 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3339 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3340 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3341 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3342 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3343 return context;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3344 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3345 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3346 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
3347 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3348 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3349 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3350 }
2208
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3351 int debugging = 1;
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3352 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
3353 {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3354 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
3355 }
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3356 if (debugging) {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3357 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
3358 } else {
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3359 return context;
3809a0bd680e Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents: 2198
diff changeset
3360 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3361 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3362 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3363 }
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
3364 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
3365 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode
Michael Pavone <pavone@retrodev.com>
parents: 1111
diff changeset
3366 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
3367 }
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
3368 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
3369 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
3370 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
3371 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
3372 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
3373 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
3374 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3375 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3376 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3377 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
3378 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
3379 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3380 }
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
3381
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3382 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3383 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
3384 debugger_repl(root);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3385 return context;
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
548
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3388 #endif
a3afee2271ce Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents: 525
diff changeset
3389
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
3390 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
3391 {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3392 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3393 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3394 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
3395
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
3396 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
3397
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
3398 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
3399 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3400 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3401 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents: 2054
diff changeset
3402 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3403 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
3404 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
3405 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
3406 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3407 //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
3408 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
3409 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
3410 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
3411 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
3412 remove_breakpoint(context, root->branch_f);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3413 }
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
3414 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
3415 } 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
3416 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
3417 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
3418 remove_breakpoint(context, root->branch_t);
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3419 }
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
3420 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
3421 }
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
3422
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3423 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
3424 int debugging = 1;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3425 //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
3426 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
3427 if (*this_bp) {
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3428 if ((*this_bp)->condition) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3429 uint32_t condres;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3430 if (eval_expr(root, (*this_bp)->condition, &condres)) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3431 if (!condres) {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3432 return;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3433 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3434 } else {
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3435 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
3436 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3437 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3438 }
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3439 }
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3440 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
3441 {
2178
f6d5bde4d07f Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents: 2177
diff changeset
3442 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
3443 }
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents: 829
diff changeset
3444 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
3445 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
3446 } 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
3447 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
3448 }
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3449 } else {
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3450 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3451 }
2182
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3452 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
3453 root->after = after;
2d7f8195be3b Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents: 2181
diff changeset
3454 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
3455 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
3456 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
3457 make_format_str(format_str, cur->format);
2183
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3458 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3459 {
eb2e0e61b1b4 Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents: 2182
diff changeset
3460 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
3461 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
3462 }
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
3463 }
2214
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents: 2208
diff changeset
3464 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
3465 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
3466 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
3467 return;
524
fb39534b6604 Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3468 }