Mercurial > repos > blastem
annotate debug.c @ 2395:ebca8ab02701
Basic string support in debugger language
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 13 Dec 2023 20:09:18 -0800 |
parents | 340299a76db7 |
children | bf4f1a8d1d48 |
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 | 7 #include <ctype.h> |
2366
1e36d8a2633c
Add missing math.h include
Michael Pavone <pavone@retrodev.com>
parents:
2365
diff
changeset
|
8 #include <math.h> |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
9 #include <stdlib.h> |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 #include <string.h> |
745
daa31ee7d8cd
Get windows build compiling again post-merge
Michael Pavone <pavone@retrodev.com>
parents:
723
diff
changeset
|
11 #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
|
12 #include <sys/select.h> |
745
daa31ee7d8cd
Get windows build compiling again post-merge
Michael Pavone <pavone@retrodev.com>
parents:
723
diff
changeset
|
13 #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
|
14 #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
|
15 #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
|
16 #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
|
17 #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
|
18 #ifndef NO_Z80 |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
19 #include "sms.h" |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
20 #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
|
21 |
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 #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
|
23 #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
|
24 #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
|
25 #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
|
26 #endif |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
27 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
28 static debug_func *funcs; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
29 static uint32_t num_funcs, func_storage; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
30 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
31 static debug_func* alloc_func(void) |
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
|
32 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
33 if (num_funcs == func_storage) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
34 func_storage = func_storage ? func_storage * 2 : 4; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
35 funcs = realloc(funcs, sizeof(debug_func) * func_storage); |
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
|
36 } |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
37 return funcs + num_funcs++; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
38 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
39 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
40 static debug_val new_native_func(debug_native_func impl, int max_args, int min_args) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
41 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
42 debug_func *f = alloc_func(); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
43 f->impl.native = impl; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
44 f->max_args = max_args; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
45 f->min_args = min_args; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
46 f->is_native = 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
47 return (debug_val) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
48 .v = { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
49 .u32 = f - funcs |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
50 }, |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
51 .type = DBG_VAL_FUNC |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
52 }; |
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
|
53 } |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
54 |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
55 static debug_val new_user_func(command_block *block, char **args, int num_args) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
56 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
57 debug_func *f = alloc_func(); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
58 f->impl.block = *block; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
59 f->arg_names = args; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
60 f->max_args = f->min_args = num_args; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
61 f->is_native = 0; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
62 return (debug_val) { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
63 .v = { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
64 .u32 = f - funcs |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
65 }, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
66 .type = DBG_VAL_FUNC |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
67 }; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
68 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
69 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
70 debug_val user_var_get(debug_var *var) |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
71 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
72 return var->val; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
73 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
74 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
75 void user_var_set(debug_var *var, debug_val val) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
76 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
77 var->val = val; |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
78 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
79 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
80 static void new_user_variable(debug_root *root, const char *name, debug_val val) |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
81 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
82 debug_var *var = calloc(1, sizeof(debug_var)); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
83 var->get = user_var_get; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
84 var->set = user_var_set; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
85 var->val = val; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
86 root->variables = tern_insert_ptr(root->variables, name, var); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
87 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
88 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
89 static void new_readonly_variable(debug_root *root, const char *name, debug_val val) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
90 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
91 debug_var *var = calloc(1, sizeof(debug_var)); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
92 var->get = user_var_get; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
93 var->set = NULL; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
94 var->val = val; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
95 root->variables = tern_insert_ptr(root->variables, name, var); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
96 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
97 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
98 static debug_array *arrays; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
99 static uint32_t num_arrays, array_storage; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
100 static debug_array *alloc_array(void) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
101 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
102 if (num_arrays == array_storage) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
103 array_storage = array_storage ? array_storage * 2 : 4; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
104 arrays = realloc(arrays, sizeof(debug_array) * array_storage); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
105 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
106 return arrays + num_arrays++; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
107 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
108 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
109 static debug_val new_fixed_array(void *base, debug_array_get get, debug_array_set set, uint32_t size) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
110 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
111 debug_array *array = alloc_array(); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
112 array->get = get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
113 array->set = set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
114 array->append = NULL; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
115 array->base = base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
116 array->size = array->storage = size; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
117 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
118 ret.type = DBG_VAL_ARRAY; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
119 ret.v.u32 = array - arrays; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
120 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
121 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
122 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
123 static debug_val user_array_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
124 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
125 debug_val *data = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
126 return data[index]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
127 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
128 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
129 static void user_array_set(debug_array *array, uint32_t index, debug_val value) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
130 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
131 debug_val *data = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
132 data[index] = value; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
133 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
134 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
135 static void user_array_append(debug_array *array, debug_val value) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
136 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
137 if (array->size == array->storage) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
138 array->storage *= 2; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
139 array->base = realloc(array->base, sizeof(debug_val) * array->storage); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
140 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
141 debug_val *data = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
142 data[array->size++] = value; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
143 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
144 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
145 static debug_val new_user_array(uint32_t size) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
146 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
147 debug_array *array = alloc_array(); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
148 array->get = user_array_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
149 array->set = user_array_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
150 array->append = user_array_append; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
151 array->size = size; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
152 array->storage = size ? size : 4; |
2394
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
153 array->base = calloc(array->storage, sizeof(debug_val)); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
154 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
155 ret.type = DBG_VAL_ARRAY; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
156 ret.v.u32 = array - arrays; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
157 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
158 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
159 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
160 debug_array *get_array(debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
161 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
162 if (val.type != DBG_VAL_ARRAY) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
163 return NULL; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
164 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
165 return arrays + val.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
166 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
167 |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
168 static debug_string **debug_strings; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
169 static uint32_t num_debug_strings; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
170 static uint32_t debug_string_storage; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
171 static debug_val new_debug_string(char *str) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
172 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
173 if (num_debug_strings == debug_string_storage) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
174 debug_string_storage = debug_string_storage ? 2 * debug_string_storage : 4; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
175 debug_strings = realloc(debug_strings, debug_string_storage * sizeof(debug_string*)); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
176 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
177 debug_string *string = calloc(1, sizeof(debug_string)); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
178 string->size = string->storage = strlen(str); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
179 string->buffer = calloc(1, string->size + 1); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
180 memcpy(string->buffer, str, string->size + 1); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
181 debug_strings[num_debug_strings] = string; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
182 return (debug_val){ |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
183 .type = DBG_VAL_STRING, |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
184 .v = { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
185 .u32 = num_debug_strings++ |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
186 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
187 }; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
188 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
189 |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
190 static debug_string* get_string(debug_val val) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
191 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
192 if (val.type != DBG_VAL_STRING) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
193 return NULL; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
194 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
195 return debug_strings[val.v.u32]; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
196 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
197 |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
198 static char* get_cstring(debug_val val) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
199 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
200 debug_string *str = get_string(val); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
201 if (!str) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
202 return NULL; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
203 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
204 return str->buffer; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
205 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
206 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
207 static uint8_t debug_cast_int(debug_val val, uint32_t *out) |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
208 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
209 if (val.type == DBG_VAL_U32) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
210 *out = val.v.u32; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
211 return 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
212 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
213 if (val.type == DBG_VAL_F32) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
214 *out = val.v.f32; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
215 return 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
216 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
217 return 0; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
218 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
219 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
220 static uint8_t debug_cast_float(debug_val val, float *out) |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
221 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
222 if (val.type == DBG_VAL_U32) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
223 *out = val.v.u32; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
224 return 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
225 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
226 if (val.type == DBG_VAL_F32) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
227 *out = val.v.f32; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
228 return 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
229 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
230 return 0; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
231 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
232 |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
233 static uint8_t debug_cast_bool(debug_val val) |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
234 { |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
235 switch(val.type) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
236 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
237 case DBG_VAL_U32: return val.v.u32 != 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
238 case DBG_VAL_F32: return val.v.f32 != 0.0f; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
239 case DBG_VAL_ARRAY: return get_array(val)->size != 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
240 default: return 1; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
241 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
242 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
243 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
244 static debug_val debug_int(uint32_t i) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
245 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
246 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
247 ret.type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
248 ret.v.u32 = i; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
249 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
250 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
251 |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
252 static debug_val debug_float(float f) |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
253 { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
254 return (debug_val) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
255 .type = DBG_VAL_F32, |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
256 .v = { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
257 .f32 = f |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
258 } |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
259 }; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
260 } |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
261 |
2367
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
262 static debug_val debug_sin(debug_val *args, int num_args) |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
263 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
264 float f; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
265 if (!debug_cast_float(args[0], &f)) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
266 return debug_float(0.0f); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
267 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
268 return debug_float(sinf(f)); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
269 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
270 |
2367
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
271 static debug_val debug_cos(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
272 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
273 float f; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
274 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
275 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
276 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
277 return debug_float(cosf(f)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
278 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
279 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
280 static debug_val debug_tan(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
281 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
282 float f; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
283 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
284 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
285 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
286 return debug_float(tanf(f)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
287 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
288 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
289 static debug_val debug_asin(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
290 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
291 float f; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
292 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
293 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
294 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
295 return debug_float(asinf(f)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
296 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
297 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
298 static debug_val debug_acos(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
299 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
300 float f; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
301 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
302 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
303 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
304 return debug_float(acosf(f)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
305 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
306 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
307 static debug_val debug_atan(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
308 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
309 float f; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
310 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
311 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
312 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
313 return debug_float(atanf(f)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
314 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
315 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
316 static debug_val debug_atan2(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
317 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
318 float f, f2; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
319 if (!debug_cast_float(args[0], &f)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
320 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
321 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
322 if (!debug_cast_float(args[1], &f2)) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
323 return debug_float(0.0f); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
324 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
325 return debug_float(atan2f(f, f2)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
326 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
327 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
328 static debug_val array_pop(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
329 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
330 debug_array *array = get_array(*args); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
331 if (!array) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
332 return debug_int(0); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
333 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
334 debug_val ret = array->get(array, array->size - 1); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
335 if (array->append) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
336 array->size--; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
337 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
338 return ret; |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
339 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
340 |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
341 static debug_val debug_size(debug_val *args, int num_args) |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
342 { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
343 debug_array *array = get_array(*args); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
344 if (!array) { |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
345 //TODO: string support |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
346 return debug_int(0); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
347 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
348 return debug_int(array->size); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
349 } |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
350 |
2380
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
351 static debug_root **roots; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
352 static uint32_t num_roots, root_storage; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
353 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
354 debug_root *find_root(void *cpu) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
355 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
356 for (uint32_t i = 0; i < num_roots; i++) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
357 { |
2380
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
358 if (roots[i]->cpu_context == cpu) { |
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
359 return roots[i]; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
360 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
361 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
362 if (num_roots == root_storage) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
363 root_storage = root_storage ? root_storage * 2 : 5; |
2380
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
364 roots = realloc(roots, root_storage * sizeof(debug_root*)); |
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
365 } |
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
366 debug_root *root = calloc(1, sizeof(debug_root)); |
1b21290358a8
Fix regression in debugger for Mega CD
Michael Pavone <pavone@retrodev.com>
parents:
2371
diff
changeset
|
367 roots[num_roots++] = root; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
368 root->cpu_context = cpu; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
369 new_readonly_variable(root, "sin", new_native_func(debug_sin, 1, 1)); |
2367
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
370 new_readonly_variable(root, "cos", new_native_func(debug_cos, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
371 new_readonly_variable(root, "tan", new_native_func(debug_tan, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
372 new_readonly_variable(root, "asin", new_native_func(debug_asin, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
373 new_readonly_variable(root, "acos", new_native_func(debug_acos, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
374 new_readonly_variable(root, "atan", new_native_func(debug_atan, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
375 new_readonly_variable(root, "atan2", new_native_func(debug_atan2, 2, 2)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
376 new_readonly_variable(root, "pop", new_native_func(array_pop, 1, 1)); |
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
377 new_readonly_variable(root, "size", new_native_func(debug_size, 1, 1)); |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
378 return root; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
379 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
380 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
381 bp_def ** find_breakpoint(bp_def ** cur, uint32_t address, uint8_t type) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
382 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
383 while (*cur) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
384 if ((*cur)->type == type && (*cur)->address == (((*cur)->mask) & address)) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
385 break; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
386 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
387 cur = &((*cur)->next); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
388 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
389 return cur; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
390 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
391 |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
392 bp_def ** find_breakpoint_idx(bp_def ** cur, uint32_t index) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
393 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
394 while (*cur) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
395 if ((*cur)->index == index) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
396 break; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
397 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
398 cur = &((*cur)->next); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
399 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
400 return cur; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
401 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
402 |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
403 static const char *token_type_names[] = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
404 "TOKEN_NONE", |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
405 "TOKEN_INT", |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
406 "TOKEN_DECIMAL", |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
407 "TOKEN_NAME", |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
408 "TOKEN_ARRAY", |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
409 "TOKEN_FUNCALL", |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
410 "TOKEN_OPER", |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
411 "TOKEN_SIZE", |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
412 "TOKEN_LBRACKET", |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
413 "TOKEN_RBRACKET", |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
414 "TOKEN_LPAREN", |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
415 "TOKEN_RPAREN", |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
416 "TOKEN_STRING" |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
417 }; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
418 |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
419 static char *parse_string_literal(char *start, char **end) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
420 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
421 uint32_t length = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
422 uint8_t is_escape = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
423 char *cur; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
424 for (cur = start; *cur && *cur != '"'; cur++) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
425 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
426 if (is_escape) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
427 switch (*cur) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
428 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
429 case 't': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
430 case 'n': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
431 case 'r': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
432 case '\\': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
433 break; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
434 default: |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
435 fprintf(stderr, "Unsupported escape character %c\n", *cur); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
436 return NULL; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
437 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
438 is_escape = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
439 } else if (*cur == '\\') { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
440 is_escape = 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
441 continue; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
442 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
443 length++; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
444 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
445 if (!*cur) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
446 fprintf(stderr, "Unterminated string literal: %s\n", start); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
447 return NULL; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
448 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
449 *end = cur + 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
450 char *ret = calloc(1, length + 1); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
451 char *dst = ret; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
452 is_escape = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
453 for (cur = start; *cur != '"'; ++cur) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
454 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
455 if (is_escape) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
456 switch (*cur) |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
457 { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
458 case 't': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
459 *(dst++) = '\t'; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
460 break; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
461 case 'n': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
462 *(dst++) = '\n'; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
463 break; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
464 case 'r': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
465 *(dst++) = '\r'; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
466 break; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
467 case '\\': |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
468 *(dst++) = '\\'; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
469 break; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
470 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
471 is_escape = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
472 } else if (*cur == '\\') { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
473 is_escape = 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
474 continue; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
475 } else { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
476 *(dst++) = *cur; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
477 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
478 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
479 *dst = 0; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
480 return ret; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
481 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
482 |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
483 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
|
484 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
485 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
|
486 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
487 ++start; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
488 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
489 if (!*start || *start == '\n' || *start == '\r') { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
490 *end = start; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
491 return (token){ |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
492 .type = TOKEN_NONE |
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 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
495 if (*start == '$' || (*start == '0' && start[1] == 'x')) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
496 return (token) { |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
497 .type = TOKEN_INT, |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
498 .v = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
499 .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
|
500 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
501 }; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
502 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
503 if (*start == '"') { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
504 char *str = parse_string_literal(start + 1, end); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
505 if (!str) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
506 *end = start; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
507 return (token){ |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
508 .type = TOKEN_NONE |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
509 }; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
510 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
511 return (token){ |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
512 .type = TOKEN_STRING, |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
513 .v = { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
514 .str = str |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
515 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
516 }; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
517 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
518 if (isdigit(*start)) { |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
519 uint32_t ipart = strtol(start, end, 10); |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
520 if (**end == '.') { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
521 start = *end + 1; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
522 uint32_t fpart = strtol(start, end, 10); |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
523 float fval; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
524 if (fpart) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
525 float divisor = powf(10.0f, *end - start); |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
526 fval = ipart + fpart / divisor; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
527 } else { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
528 fval = ipart; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
529 } |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
530 return (token) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
531 .type = TOKEN_DECIMAL, |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
532 .v = { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
533 .f = fval |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
534 } |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
535 }; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
536 } else { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
537 return (token) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
538 .type = TOKEN_INT, |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
539 .v = { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
540 .num = ipart |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
541 } |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
542 }; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
543 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
544 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
545 switch (*start) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
546 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
547 case '+': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
548 case '-': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
549 case '*': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
550 case '/': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
551 case '&': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
552 case '|': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
553 case '^': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
554 case '~': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
555 case '=': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
556 case '!': |
2191
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
557 case '>': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
558 case '<': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
559 if ((*start == '!' || *start == '>' || *start == '<') && start[1] == '=') { |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
560 *end = start + 2; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
561 return (token) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
562 .type = TOKEN_OPER, |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
563 .v = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
564 .op = {*start, start[1], 0} |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
565 } |
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 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
568 *end = start + 1; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
569 return (token) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
570 .type = TOKEN_OPER, |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
571 .v = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
572 .op = {*start, 0} |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
573 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
574 }; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
575 case '.': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
576 *end = start + 2; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
577 return (token) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
578 .type = TOKEN_SIZE, |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
579 .v = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
580 .op = {start[1], 0} |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
581 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
582 }; |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
583 case '[': |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
584 *end = start + 1; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
585 return (token) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
586 .type = TOKEN_LBRACKET |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
587 }; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
588 case ']': |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
589 *end = start + 1; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
590 return (token) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
591 .type = TOKEN_RBRACKET |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
592 }; |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
593 case '(': |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
594 *end = start + 1; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
595 return (token) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
596 .type = TOKEN_LPAREN |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
597 }; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
598 case ')': |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
599 *end = start + 1; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
600 return (token) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
601 .type = TOKEN_RPAREN |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
602 }; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
603 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
604 *end = start + 1; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
605 token_type type = TOKEN_NAME; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
606 while (**end && !isspace(**end)) |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
607 { |
2172
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
608 uint8_t done = 0; |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
609 switch (**end) |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
610 { |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
611 case '[': |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
612 type = TOKEN_ARRAY; |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
613 done = 1; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
614 break; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
615 case '(': |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
616 type = TOKEN_FUNCALL; |
2172
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
617 case '+': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
618 case '-': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
619 case '*': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
620 case '/': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
621 case '&': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
622 case '|': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
623 case '^': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
624 case '~': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
625 case '=': |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
626 case '!': |
2191
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
627 case '>': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
628 case '<': |
2172
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
629 case '.': |
2357
344c6a3fe8a8
Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents:
2302
diff
changeset
|
630 case ']': |
344c6a3fe8a8
Fix annoying bug in debugger tokenizer
Michael Pavone <pavone@retrodev.com>
parents:
2302
diff
changeset
|
631 case ')': |
2172
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
632 done = 1; |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
633 break; |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
634 } |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
635 if (done) { |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
636 break; |
a00773a336d8
Fix bug in debugger lexer
Michael Pavone <pavone@retrodev.com>
parents:
2171
diff
changeset
|
637 } |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
638 |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
639 ++*end; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
640 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
641 char *name = malloc(*end - start + 1); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
642 memcpy(name, start, *end - start); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
643 name[*end-start] = 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
644 return (token) { |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
645 .type = type, |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
646 .v = { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
647 .str = name |
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 }; |
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 |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
652 static void free_expr(expr *e); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
653 static void free_expr_int(expr *e) |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
654 { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
655 free_expr(e->left); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
656 if (e->type == EXPR_FUNCALL) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
657 for (uint32_t i = 0; i < e->op.v.num; i++) |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
658 { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
659 free_expr_int(e->right + i); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
660 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
661 free(e->right); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
662 } else { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
663 free_expr(e->right); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
664 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
665 if (e->op.type == TOKEN_NAME || e->op.type == TOKEN_ARRAY || e->op.type == TOKEN_STRING) { |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
666 free(e->op.v.str); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
667 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
668 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
669 |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
670 static void free_expr(expr *e) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
671 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
672 if (!e) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
673 return; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
674 } |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
675 free_expr_int(e); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
676 free(e); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
677 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
678 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
679 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
|
680 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
|
681 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
682 static void handle_namespace(expr *e) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
683 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
684 if (e->op.type != TOKEN_NAME && e->op.type != TOKEN_ARRAY) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
685 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
686 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
687 char *start = e->op.v.str; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
688 char *orig_start = start; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
689 for (char *cur = start; *cur; ++cur) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
690 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
691 if (*cur == ':') { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
692 char *ns = malloc(cur - start + 1); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
693 memcpy(ns, start, cur - start); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
694 ns[cur - start] = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
695 expr *inner = calloc(1, sizeof(expr)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
696 inner->type = EXPR_SCALAR; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
697 inner->op.type = TOKEN_NAME; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
698 start = cur + 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
699 inner->op.v.str = start; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
700 e->left = inner; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
701 e->type = EXPR_NAMESPACE; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
702 e->op.v.str = ns; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
703 e = inner; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
704 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
705 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
706 if (start != orig_start) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
707 //We've split the original string up into |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
708 //a bunch of individually allocated fragments |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
709 //this is just a little stup of the original |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
710 e->op.v.str = strdup(e->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
711 free(orig_start); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
712 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
713 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
714 |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
715 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
|
716 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
717 char *after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
718 token first = parse_token(start, &after_first); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
719 if (!first.type) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
720 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
721 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
722 if (first.type == TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
723 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
|
724 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
725 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
726 if (first.type == TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
727 expr *target = parse_scalar(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
728 if (!target) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
729 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
|
730 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
731 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
732 expr *ret = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
733 ret->type = EXPR_UNARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
734 ret->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
735 ret->left = target; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
736 *end = after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
737 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
738 } |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
739 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) { |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
740 expr *ret = calloc(1, sizeof(expr)); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
741 ret->type = EXPR_MEM; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
742 if (first.type == TOKEN_ARRAY) { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
743 //current token is the array name |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
744 //consume the bracket token |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
745 parse_token(after_first, &after_first); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
746 ret->right = calloc(1, sizeof(expr)); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
747 ret->right->type = EXPR_SCALAR; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
748 ret->right->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
749 handle_namespace(ret->right); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
750 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
751 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
752 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
|
753 if (!ret->left) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
754 fprintf(stderr, "Expression expected after `[`\n"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
755 free(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
756 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
757 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
758 token rbrack = parse_token(*end, end); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
759 if (rbrack.type != TOKEN_RBRACKET) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
760 fprintf(stderr, "Missing closing `]`"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
761 free_expr(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
762 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
763 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
764 char *after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
765 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
|
766 if (size.type == TOKEN_SIZE) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
767 *end = after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
768 ret->op = size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
769 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
770 return ret; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
771 } |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
772 if (first.type == TOKEN_LPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
773 expr *ret = parse_expression(after_first, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
774 if (!ret) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
775 fprintf(stderr, "Expression expected after `(`\n"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
776 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
777 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
778 token rparen = parse_token(*end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
779 if (rparen.type != TOKEN_RPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
780 fprintf(stderr, "Missing closing `)`"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
781 free_expr(ret); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
782 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
783 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
784 return ret; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
785 } |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
786 if (first.type == TOKEN_FUNCALL) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
787 expr *ret = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
788 ret->left = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
789 ret->left->type = EXPR_SCALAR; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
790 ret->left->op = first; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
791 ret->left->op.type = TOKEN_NAME; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
792 uint32_t storage = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
793 ret->op.v.num = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
794 token next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
795 while (next.type != TOKEN_RPAREN && next.type != TOKEN_NONE) |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
796 { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
797 expr *e = parse_expression(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
798 if (!e) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
799 fprintf(stderr, "Expression expected after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
800 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
801 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
802 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
803 if (storage == ret->op.v.num) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
804 storage = storage ? storage * 2 : 1; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
805 ret->right = realloc(ret->right, storage * sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
806 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
807 ret->right[ret->op.v.num++] = *e; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
808 free(e); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
809 after_first = *end; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
810 next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
811 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
812 if (next.type != TOKEN_RPAREN) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
813 fprintf(stderr, "Missing ')' after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
814 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
815 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
816 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
817 return ret; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
818 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
819 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME && first.type != TOKEN_STRING) { |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
820 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
|
821 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
822 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
823 token second = parse_token(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
824 if (second.type != TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
825 expr *ret = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
826 ret->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
827 ret->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
828 handle_namespace(ret); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
829 *end = after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
830 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
831 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
832 expr *ret = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
833 ret->type = EXPR_SIZE; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
834 ret->left = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
835 ret->left->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
836 ret->left->op = second; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
837 handle_namespace(ret->left); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
838 ret->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
839 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
840 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
841 |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
842 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
|
843 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
844 char *after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
845 token first = parse_token(start, &after_first); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
846 if (first.type != TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
847 *end = start; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
848 return left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
849 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
850 expr *bin = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
851 bin->left = left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
852 bin->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
853 bin->type = EXPR_BINARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
854 switch (first.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
855 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
856 case '*': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
857 case '/': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
858 case '&': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
859 case '|': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
860 case '^': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
861 bin->right = parse_scalar(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
862 return maybe_binary(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
863 case '+': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
864 case '-': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
865 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
|
866 return maybe_binary(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
867 case '=': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
868 case '!': |
2191
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
869 case '>': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
870 case '<': |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
871 bin->right = parse_expression(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
872 return bin; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
873 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
874 bin->left = NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
875 free(bin); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
876 return left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
877 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
878 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
879 |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
880 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
|
881 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
882 char *after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
883 token first = parse_token(start, &after_first); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
884 if (first.type != TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
885 *end = start; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
886 return left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
887 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
888 expr *bin = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
889 bin->left = left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
890 bin->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
891 bin->type = EXPR_BINARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
892 switch (first.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
893 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
894 case '*': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
895 case '/': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
896 case '&': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
897 case '|': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
898 case '^': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
899 bin->right = parse_scalar(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
900 return maybe_binary(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
901 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
902 bin->left = NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
903 free(bin); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
904 return left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
905 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
906 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
907 |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
908 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
|
909 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
910 char *after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
911 token first = parse_token(start, &after_first); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
912 if (!first.type) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
913 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
914 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
915 if (first.type == TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
916 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
|
917 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
918 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
919 if (first.type == TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
920 expr *target = parse_scalar(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
921 if (!target) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
922 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
|
923 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
924 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
925 expr *ret = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
926 ret->type = EXPR_UNARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
927 ret->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
928 ret->left = target; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
929 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
930 } |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
931 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) { |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
932 expr *ret = calloc(1, sizeof(expr)); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
933 ret->type = EXPR_MEM; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
934 if (first.type == TOKEN_ARRAY) { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
935 //current token is the array name |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
936 //consume the bracket token |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
937 parse_token(after_first, &after_first); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
938 ret->right = calloc(1, sizeof(expr)); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
939 ret->right->type = EXPR_SCALAR; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
940 ret->right->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
941 handle_namespace(ret->right); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
942 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
943 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
944 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
|
945 if (!ret->left) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
946 fprintf(stderr, "Expression expected after `[`\n"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
947 free(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
948 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
949 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
950 token rbrack = parse_token(*end, end); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
951 if (rbrack.type != TOKEN_RBRACKET) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
952 fprintf(stderr, "Missing closing `]`"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
953 free_expr(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
954 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
955 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
956 char *after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
957 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
|
958 if (size.type == TOKEN_SIZE) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
959 *end = after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
960 ret->op = size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
961 } |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
962 return maybe_muldiv(ret, *end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
963 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
964 if (first.type == TOKEN_LPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
965 expr *ret = parse_expression(after_first, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
966 if (!ret) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
967 fprintf(stderr, "Expression expected after `(`\n"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
968 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
969 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
970 token rparen = parse_token(*end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
971 if (rparen.type != TOKEN_RPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
972 fprintf(stderr, "Missing closing `)`"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
973 free_expr(ret); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
974 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
975 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
976 return maybe_muldiv(ret, *end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
977 } |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
978 if (first.type == TOKEN_FUNCALL) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
979 expr *ret = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
980 ret->left = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
981 ret->left->type = EXPR_SCALAR; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
982 ret->left->op = first; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
983 ret->left->op.type = TOKEN_NAME; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
984 uint32_t storage = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
985 ret->op.v.num = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
986 token next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
987 while (next.type != TOKEN_RPAREN && next.type != TOKEN_NONE) |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
988 { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
989 expr *e = parse_expression(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
990 if (!e) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
991 fprintf(stderr, "Expression expected after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
992 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
993 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
994 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
995 if (storage == ret->op.v.num) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
996 storage = storage ? storage * 2 : 1; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
997 ret->right = realloc(ret->right, storage * sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
998 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
999 ret->right[ret->op.v.num++] = *e; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1000 free(e); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1001 after_first = *end; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1002 next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1003 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1004 if (next.type != TOKEN_RPAREN) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1005 fprintf(stderr, "Missing ')' after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1006 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1007 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1008 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1009 return maybe_muldiv(ret, *end, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1010 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1011 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME && first.type != TOKEN_STRING) { |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1012 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
|
1013 return NULL; |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1014 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1015 char *after_second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1016 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
|
1017 if (second.type == TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1018 expr *ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1019 expr *bin = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1020 bin->type = EXPR_BINARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1021 bin->left = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1022 bin->left->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1023 bin->left->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1024 handle_namespace(bin->left); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1025 bin->op = second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1026 switch (second.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1027 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1028 case '*': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1029 case '/': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1030 case '&': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1031 case '|': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1032 case '^': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1033 bin->right = parse_scalar(after_second, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1034 return maybe_muldiv(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1035 case '+': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1036 case '-': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1037 case '=': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1038 case '!': |
2191
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
1039 case '>': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
1040 case '<': |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1041 ret = bin->left; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1042 bin->left = NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1043 free_expr(bin); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1044 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1045 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1046 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
|
1047 free(bin->left); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1048 free(bin); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1049 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1050 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1051 } else if (second.type == TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1052 expr *value = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1053 value->type = EXPR_SIZE; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1054 value->op = second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1055 value->left = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1056 value->left->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1057 value->left->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1058 handle_namespace(value->left); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1059 return maybe_muldiv(value, after_second, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1060 } else { |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1061 expr *ret = calloc(1, sizeof(expr)); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1062 ret->type = EXPR_SCALAR; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1063 ret->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1064 handle_namespace(ret); |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1065 *end = after_first; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1066 return ret; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1067 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1068 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1069 |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1070 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
|
1071 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1072 char *after_first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1073 token first = parse_token(start, &after_first); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1074 if (!first.type) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1075 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1076 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1077 if (first.type == TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1078 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
|
1079 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1080 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1081 if (first.type == TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1082 expr *target = parse_scalar(after_first, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1083 if (!target) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1084 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
|
1085 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1086 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1087 expr *ret = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1088 ret->type = EXPR_UNARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1089 ret->op = first; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1090 ret->left = target; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1091 return ret; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1092 } |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1093 if (first.type == TOKEN_LBRACKET || first.type == TOKEN_ARRAY) { |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1094 expr *ret = calloc(1, sizeof(expr)); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1095 ret->type = EXPR_MEM; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1096 if (first.type == TOKEN_ARRAY) { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1097 //current token is the array name |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1098 //consume the bracket token |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1099 parse_token(after_first, &after_first); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1100 ret->right = calloc(1, sizeof(expr)); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1101 ret->right->type = EXPR_SCALAR; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1102 ret->right->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1103 handle_namespace(ret->right); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1104 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1105 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1106 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
|
1107 if (!ret->left) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1108 fprintf(stderr, "Expression expected after `[`\n"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1109 free(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1110 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1111 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1112 token rbrack = parse_token(*end, end); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1113 if (rbrack.type != TOKEN_RBRACKET) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1114 fprintf(stderr, "Missing closing `]`"); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1115 free_expr(ret); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1116 return NULL; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1117 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1118 char *after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1119 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
|
1120 if (size.type == TOKEN_SIZE) { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1121 *end = after_size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1122 ret->op = size; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1123 } |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1124 return maybe_binary(ret, *end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1125 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1126 if (first.type == TOKEN_LPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1127 expr *ret = parse_expression(after_first, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1128 if (!ret) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1129 fprintf(stderr, "Expression expected after `(`\n"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1130 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1131 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1132 token rparen = parse_token(*end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1133 if (rparen.type != TOKEN_RPAREN) { |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1134 fprintf(stderr, "Missing closing `)`"); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1135 free_expr(ret); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1136 return NULL; |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1137 } |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1138 return maybe_binary(ret, *end, end); |
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1139 } |
2364
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1140 if (first.type == TOKEN_FUNCALL) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1141 expr *ret = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1142 ret->type = EXPR_FUNCALL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1143 ret->left = calloc(1, sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1144 ret->left->type = EXPR_SCALAR; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1145 ret->left->op = first; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1146 ret->left->op.type = TOKEN_NAME; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1147 uint32_t storage = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1148 ret->op.v.num = 0; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1149 //consume LPAREN |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1150 parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1151 after_first = *end; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1152 token next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1153 while (next.type != TOKEN_RPAREN && next.type != TOKEN_NONE) |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1154 { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1155 expr *e = parse_expression(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1156 if (!e) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1157 fprintf(stderr, "Expression expected after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1158 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1159 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1160 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1161 if (storage == ret->op.v.num) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1162 storage = storage ? storage * 2 : 1; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1163 ret->right = realloc(ret->right, storage * sizeof(expr)); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1164 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1165 ret->right[ret->op.v.num++] = *e; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1166 free(e); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1167 after_first = *end; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1168 next = parse_token(after_first, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1169 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1170 if (next.type != TOKEN_RPAREN) { |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1171 fprintf(stderr, "Missing ')' after '('\n"); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1172 free_expr(ret); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1173 return NULL; |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1174 } |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1175 return maybe_binary(ret, *end, end); |
c822bb628fc3
Add support for function call expressions in debug parser
Michael Pavone <pavone@retrodev.com>
parents:
2363
diff
changeset
|
1176 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1177 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME && first.type != TOKEN_STRING) { |
2171
4b47155965c8
Implement parentheses in debugger parser
Michael Pavone <pavone@retrodev.com>
parents:
2170
diff
changeset
|
1178 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
|
1179 return NULL; |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1180 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1181 char *after_second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1182 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
|
1183 if (second.type == TOKEN_OPER) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1184 expr *bin = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1185 bin->type = EXPR_BINARY; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1186 bin->left = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1187 bin->left->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1188 bin->left->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1189 handle_namespace(bin->left); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1190 bin->op = second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1191 switch (second.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1192 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1193 case '*': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1194 case '/': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1195 case '&': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1196 case '|': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1197 case '^': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1198 bin->right = parse_scalar(after_second, end); |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1199 if (!bin->right) { |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1200 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
|
1201 free_expr(bin); |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1202 return NULL; |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1203 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1204 return maybe_binary(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1205 case '+': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1206 case '-': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1207 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
|
1208 if (!bin->right) { |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1209 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
|
1210 free_expr(bin); |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1211 return NULL; |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1212 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1213 return maybe_binary(bin, *end, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1214 case '=': |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1215 case '!': |
2191
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
1216 case '>': |
d87a76afbd8a
Add '>', '<', '>=' and '<=' operators to debugger expression engine
Michael Pavone <pavone@retrodev.com>
parents:
2190
diff
changeset
|
1217 case '<': |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1218 bin->right = parse_expression(after_second, end); |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1219 if (!bin->right) { |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1220 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
|
1221 free_expr(bin); |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1222 return NULL; |
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
1223 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1224 return bin; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1225 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1226 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
|
1227 free(bin->left); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1228 free(bin); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1229 return NULL; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1230 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1231 } else if (second.type == TOKEN_SIZE) { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1232 expr *value = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1233 value->type = EXPR_SIZE; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1234 value->op = second; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1235 value->left = calloc(1, sizeof(expr)); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1236 value->left->type = EXPR_SCALAR; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1237 value->left->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1238 handle_namespace(value->left); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1239 return maybe_binary(value, after_second, end); |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1240 } else { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1241 if (second.type == TOKEN_NAME) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1242 free(second.v.str); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1243 } |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1244 expr *ret = calloc(1, sizeof(expr)); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1245 ret->type = EXPR_SCALAR; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1246 ret->op = first; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1247 handle_namespace(ret); |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1248 *end = after_first; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1249 return ret; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1250 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1251 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1252 |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1253 static uint8_t execute_block(debug_root *root, command_block * block); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1254 uint8_t eval_expr(debug_root *root, expr *e, debug_val *out) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1255 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1256 debug_val right; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1257 debug_val *args; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1258 debug_func *func; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1259 int num_args; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1260 switch(e->type) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1261 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1262 case EXPR_SCALAR: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1263 if (e->op.type == TOKEN_NAME || e->op.type == TOKEN_ARRAY) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1264 debug_var *var = tern_find_ptr(root->variables, e->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1265 if (!var) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1266 return 0; |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
1267 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1268 *out = var->get(var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1269 return 1; |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
1270 } else if (e->op.type == TOKEN_INT) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
1271 *out = debug_int(e->op.v.num); |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
1272 return 1; |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1273 } else if (e->op.type == TOKEN_DECIMAL){ |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1274 *out = debug_float(e->op.v.f); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1275 return 1; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1276 } else { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
1277 *out = new_debug_string(e->op.v.str); |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1278 return 1; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1279 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1280 case EXPR_UNARY: |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1281 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
|
1282 return 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1283 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1284 switch (e->op.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1285 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1286 case '!': |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1287 if (out->type != DBG_VAL_U32) { fprintf(stderr, "operator ! is only defined for integers"); return 0; } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1288 out->v.u32 = !out->v.u32; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1289 break; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1290 case '~': |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1291 if (out->type != DBG_VAL_U32) { fprintf(stderr, "operator ~ is only defined for integers"); return 0; } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1292 out->v.u32 = ~out->v.u32; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1293 break; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1294 case '-': |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1295 if (out->type == DBG_VAL_U32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1296 out->v.u32 = -out->v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1297 } else if (out->type == DBG_VAL_F32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1298 out->v.f32 = -out->v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1299 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1300 fprintf(stderr, "operator ~ is only defined for integers and floats"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1301 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1302 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1303 break; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1304 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1305 return 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1306 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1307 return 1; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1308 case EXPR_BINARY: |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1309 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
|
1310 return 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1311 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1312 if (out->type != right.type) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1313 if (out->type == DBG_VAL_F32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1314 if (right.type == DBG_VAL_U32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1315 right.type = DBG_VAL_F32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1316 float v = right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1317 right.v.f32 = v; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1318 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1319 fprintf(stderr, "Invalid type on right side of binary operator\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1320 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1321 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1322 } else if (out->type == DBG_VAL_U32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1323 if (right.type == DBG_VAL_F32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1324 out->type = DBG_VAL_F32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1325 float v = out->v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1326 out->v.f32 = v; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1327 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1328 fprintf(stderr, "Invalid type on right side of binary operator\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1329 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1330 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1331 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1332 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1333 if (out->type == DBG_VAL_U32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1334 switch (e->op.v.op[0]) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1335 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1336 case '+': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1337 out->v.u32 += right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1338 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1339 case '-': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1340 out->v.u32 -= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1341 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1342 case '*': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1343 out->v.u32 *= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1344 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1345 case '/': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1346 out->v.u32 /= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1347 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1348 case '&': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1349 out->v.u32 &= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1350 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1351 case '|': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1352 out->v.u32 |= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1353 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1354 case '^': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1355 out->v.u32 ^= right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1356 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1357 case '=': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1358 out->v.u32 = out->v.u32 == right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1359 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1360 case '!': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1361 out->v.u32 = out->v.u32 != right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1362 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1363 case '>': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1364 out->v.u32 = e->op.v.op[1] ? out->v.u32 >= right.v.u32 : out->v.u32 > right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1365 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1366 case '<': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1367 out->v.u32 = e->op.v.op[1] ? out->v.u32 <= right.v.u32 : out->v.u32 < right.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1368 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1369 default: |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1370 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1371 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1372 } else if (out->type == DBG_VAL_F32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1373 switch (e->op.v.op[0]) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1374 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1375 case '+': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1376 out->v.f32 += right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1377 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1378 case '-': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1379 out->v.f32 -= right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1380 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1381 case '*': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1382 out->v.f32 *= right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1383 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1384 case '/': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1385 out->v.f32 /= right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1386 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1387 case '=': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1388 out->v.u32 = out->v.f32 == right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1389 out->type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1390 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1391 case '!': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1392 out->v.u32 = out->v.f32 != right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1393 out->type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1394 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1395 case '>': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1396 out->v.u32 = e->op.v.op[1] ? out->v.f32 >= right.v.f32 : out->v.f32 > right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1397 out->type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1398 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1399 case '<': |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1400 out->v.u32 = e->op.v.op[1] ? out->v.f32 <= right.v.f32 : out->v.f32 < right.v.f32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1401 out->type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1402 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1403 default: |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1404 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1405 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1406 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1407 return 1; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1408 case EXPR_SIZE: |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1409 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
|
1410 return 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1411 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1412 if (out->type != DBG_VAL_U32) { fprintf(stderr, "Size expressions are only defined for integers"); return 0; } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1413 switch (e->op.v.op[0]) |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1414 { |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1415 case 'b': |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1416 out->v.u32 &= 0xFF; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1417 break; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1418 case 'w': |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1419 out->v.u32 &= 0xFFFF; |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1420 break; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1421 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1422 return 1; |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1423 case EXPR_MEM: |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1424 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
|
1425 return 0; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1426 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1427 if (out->type != DBG_VAL_U32) { fprintf(stderr, "Array index must be integer"); return 0; } |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1428 if (e->right) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1429 if (!eval_expr(root, e->right, &right)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1430 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1431 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1432 debug_array *array = get_array(right); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1433 if (!array) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1434 fprintf(stderr, "Attempt to index into value that is not an array"); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1435 return 0; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1436 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1437 if (out->v.u32 >= array->size) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1438 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1439 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1440 *out = array->get(array, out->v.u32); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1441 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1442 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1443 return root->read_mem(root, &out->v.u32, e->op.v.op[0]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1444 case EXPR_NAMESPACE: |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1445 root = tern_find_ptr(root->other_roots, e->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1446 if (!root) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1447 fprintf(stderr, "%s is not a valid namespace\n", e->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1448 return 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1449 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1450 return eval_expr(root, e->left, out); |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1451 case EXPR_FUNCALL: |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1452 if (!eval_expr(root, e->left, out)) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1453 return 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1454 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1455 if (out->type != DBG_VAL_FUNC) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1456 fprintf(stderr, "Funcall expression requires function"); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1457 return 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1458 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1459 func = funcs + out->v.u32; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1460 num_args = e->op.v.num; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1461 if (func->min_args > 0 && num_args < func->min_args) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1462 fprintf(stderr, "Function requires at least %d args, but %d given\n", func->min_args, num_args); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1463 return 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1464 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1465 if (func->max_args >= 0 && num_args > func->max_args) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1466 fprintf(stderr, "Function requires no more than %d args, but %d given\n", func->max_args, num_args); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1467 return 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1468 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1469 args = calloc(num_args, sizeof(debug_val)); |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1470 for (int i = 0; i < num_args; i++) |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1471 { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1472 if (!eval_expr(root, e->right + i, args + i)) { |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1473 free(args); |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1474 return 0; |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1475 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1476 } |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1477 if (func->is_native) { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1478 *out = func->impl.native(args, num_args); |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1479 free(args); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1480 return 1; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1481 } else { |
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1482 //TODO: Implement me |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1483 debug_root *func_root = calloc(1, sizeof(debug_root)); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1484 for (int i = 0; i < num_args; i++) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1485 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1486 new_user_variable(func_root, func->arg_names[i], args[i]); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1487 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1488 free(args); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1489 func_root->other_roots = tern_insert_ptr(func_root->other_roots, "parent", root); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1490 execute_block(func_root, &func->impl.block); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1491 *out = func_root->retval; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1492 //FIXME: properly free root |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1493 tern_free(func_root->variables); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1494 tern_free(func_root->other_roots); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1495 free(func_root); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
1496 return 1; |
2365
8c060849a503
Basic function call support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2364
diff
changeset
|
1497 } |
2169
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1498 default: |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1499 return 0; |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1500 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1501 } |
cb9572145f8e
WIP support for expression parsing in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2133
diff
changeset
|
1502 |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1503 char * find_param(char * buf) |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1504 { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1505 for (; *buf; buf++) { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1506 if (*buf == ' ') { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1507 if (*(buf+1)) { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1508 return buf+1; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1509 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1510 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1511 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1512 return NULL; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1513 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1514 |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1515 void strip_nl(char * buf) |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1516 { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1517 for(; *buf; buf++) { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1518 if (*buf == '\n') { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1519 *buf = 0; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1520 return; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1521 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1522 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1523 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1524 |
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
|
1525 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
|
1526 { |
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
|
1527 //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
|
1528 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
|
1529 } |
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
|
1530 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1531 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
|
1532 { |
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
|
1533 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
|
1534 } |
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
|
1535 |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1536 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
|
1537 { |
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
|
1538 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
|
1539 } |
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
|
1540 |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1541 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
|
1542 { |
2175
8c28c5466d70
Minor cleanup of debugger changes
Michael Pavone <pavone@retrodev.com>
parents:
2174
diff
changeset
|
1543 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
|
1544 if (size == 'b') { |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1545 *out = m68k_read_byte(*out, context); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1546 } else if (size == 'l') { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1547 if (*out & 1) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
1548 fprintf(stderr, "Longword access to odd addresses ($%X) is not allowed\n", *out); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1549 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1550 } |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1551 *out = m68k_read_long(*out, context); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1552 } else { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1553 if (*out & 1) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
1554 fprintf(stderr, "Wword access to odd addresses ($%X) is not allowed\n", *out); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1555 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1556 } |
2170
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1557 *out = m68k_read_word(*out, context); |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1558 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1559 return 1; |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1560 } |
ada3130b1396
Add memory indirection syntax to debugger parser/evaluator
Michael Pavone <pavone@retrodev.com>
parents:
2169
diff
changeset
|
1561 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1562 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
|
1563 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1564 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1565 if (size == 'b') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1566 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
|
1567 } else if (size == 'l') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1568 if (address & 1) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
1569 fprintf(stderr, "Longword access to odd addresses ($%X) is not allowed\n", address); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1570 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1571 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1572 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
|
1573 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
|
1574 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1575 if (address & 1) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
1576 fprintf(stderr, "Wword access to odd addresses ($%X) is not allowed\n", address); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1577 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1578 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1579 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
|
1580 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1581 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1582 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
1583 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1584 static debug_val m68k_dreg_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1585 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1586 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1587 return debug_int(context->dregs[var->val.v.u32]); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1588 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1589 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1590 static void m68k_dreg_set(debug_var *var, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1591 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1592 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1593 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1594 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1595 fprintf(stderr, "M68K register d%d can only be set to an integer\n", var->val.v.u32); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1596 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1597 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1598 context->dregs[var->val.v.u32] = ival; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1599 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1600 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1601 static debug_val m68k_areg_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1602 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1603 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1604 return debug_int(context->aregs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1605 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1606 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1607 static void m68k_areg_set(debug_var *var, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1608 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1609 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1610 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1611 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1612 fprintf(stderr, "M68K register a%d can only be set to an integer\n", var->val.v.u32); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1613 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1614 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1615 context->aregs[var->val.v.u32] = ival; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1616 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1617 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1618 static debug_val m68k_sr_get(debug_var *var) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1619 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1620 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1621 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1622 ret.v.u32 = context->status << 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1623 for (int flag = 0; flag < 5; flag++) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1624 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1625 ret.v.u32 |= context->flags[flag] << (4-flag); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1626 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1627 ret.type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1628 return ret; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1629 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1630 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1631 static void m68k_sr_set(debug_var *var, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1632 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1633 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1634 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1635 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1636 fprintf(stderr, "M68K register sr can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1637 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1638 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1639 context->status = ival >> 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1640 for (int flag = 0; flag < 5; flag++) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1641 context->flags[flag] = (ival & (1 << (4 - flag))) != 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1642 } |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1643 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1644 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1645 static debug_val m68k_cycle_get(debug_var *var) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1646 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1647 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1648 return debug_int(context->current_cycle); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1649 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1650 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1651 static debug_val m68k_usp_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1652 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1653 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1654 return debug_int(context->status & 0x20 ? context->aregs[8] : context->aregs[7]); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1655 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1656 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1657 static void m68k_usp_set(debug_var *var, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1658 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1659 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1660 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1661 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1662 fprintf(stderr, "M68K register usp can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1663 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1664 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1665 context->aregs[context->status & 0x20 ? 8 : 7] = ival; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1666 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1667 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1668 static debug_val m68k_ssp_get(debug_var *var) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1669 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1670 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1671 return debug_int(context->status & 0x20 ? context->aregs[7] : context->aregs[8]); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1672 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1673 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1674 static void m68k_ssp_set(debug_var *var, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1675 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1676 m68k_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1677 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1678 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1679 fprintf(stderr, "M68K register ssp can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1680 return; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1681 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1682 context->aregs[context->status & 0x20 ? 7 : 8] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1683 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1684 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1685 static debug_val root_address_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1686 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1687 debug_root *root = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1688 return debug_int(root->address); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1689 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1690 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1691 static void m68k_names(debug_root *root) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1692 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1693 debug_var *var; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1694 for (char i = 0; i < 8; i++) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1695 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1696 char rname[3] = {'d', '0' + i, 0}; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1697 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1698 var->get = m68k_dreg_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1699 var->set = m68k_dreg_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1700 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1701 var->val.v.u32 = i; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1702 root->variables = tern_insert_ptr(root->variables, rname, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1703 rname[0] = 'D'; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1704 root->variables = tern_insert_ptr(root->variables, rname, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1705 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1706 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1707 var->get = m68k_areg_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1708 var->set = m68k_areg_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1709 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1710 var->val.v.u32 = i; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1711 rname[0] = 'a'; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1712 root->variables = tern_insert_ptr(root->variables, rname, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1713 rname[0] = 'A'; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1714 root->variables = tern_insert_ptr(root->variables, rname, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1715 if (i == 7) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1716 root->variables = tern_insert_ptr(root->variables, "sp", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1717 root->variables = tern_insert_ptr(root->variables, "SP", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1718 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1719 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1720 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1721 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1722 var->get = m68k_sr_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1723 var->set = m68k_sr_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1724 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1725 root->variables = tern_insert_ptr(root->variables, "sr", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1726 root->variables = tern_insert_ptr(root->variables, "SR", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1727 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1728 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1729 var->get = root_address_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1730 var->ptr = root; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1731 root->variables = tern_insert_ptr(root->variables, "pc", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1732 root->variables = tern_insert_ptr(root->variables, "PC", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1733 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1734 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1735 var->get = m68k_usp_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1736 var->set = m68k_usp_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1737 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1738 root->variables = tern_insert_ptr(root->variables, "usp", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1739 root->variables = tern_insert_ptr(root->variables, "USP", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1740 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1741 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1742 var->get = m68k_ssp_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1743 var->set = m68k_ssp_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1744 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1745 root->variables = tern_insert_ptr(root->variables, "ssp", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1746 root->variables = tern_insert_ptr(root->variables, "SSP", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1747 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1748 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1749 var->get = m68k_cycle_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1750 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1751 root->variables = tern_insert_ptr(root->variables, "cycle", var); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1752 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1753 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1754 static debug_val vcounter_get(debug_var *var) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1755 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1756 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1757 return debug_int(vdp->vcounter); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1758 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1759 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1760 static debug_val hcounter_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1761 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1762 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1763 return debug_int(vdp->hslot); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1764 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1765 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1766 static debug_val vdp_address_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1767 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1768 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1769 return debug_int(vdp->address); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1770 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1771 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1772 static void vdp_address_set(debug_var *var, debug_val val) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1773 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1774 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1775 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1776 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1777 fprintf(stderr, "vdp address can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1778 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1779 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1780 vdp->address = ival & 0x1FFFF; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1781 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1782 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1783 static debug_val vdp_cd_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1784 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1785 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1786 return debug_int(vdp->cd); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1787 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1788 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1789 static void vdp_cd_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1790 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1791 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1792 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1793 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1794 fprintf(stderr, "vdp cd can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1795 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1796 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1797 vdp->cd = ival & 0x3F; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1798 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1799 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1800 static debug_val vdp_status_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1801 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1802 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1803 return debug_int(vdp_status(vdp)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1804 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1805 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1806 static debug_val debug_vram_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1807 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1808 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1809 return debug_int(vdp->vdpmem[index]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1810 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1811 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1812 static void debug_vram_set(debug_array *array, uint32_t index, debug_val val) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1813 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1814 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1815 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1816 fprintf(stderr, "vram can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1817 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1818 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1819 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1820 vdp->vdpmem[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1821 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1822 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1823 static debug_val debug_vsram_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1824 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1825 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1826 return debug_int(vdp->vsram[index] & VSRAM_BITS); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1827 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1828 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1829 static void debug_vsram_set(debug_array *array, uint32_t index, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1830 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1831 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1832 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1833 fprintf(stderr, "vsram can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1834 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1835 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1836 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1837 vdp->vsram[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1838 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1839 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1840 static debug_val debug_cram_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1841 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1842 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1843 return debug_int(vdp->cram[index] & CRAM_BITS); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1844 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1845 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1846 static void debug_cram_set(debug_array *array, uint32_t index, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1847 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1848 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1849 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1850 fprintf(stderr, "cram can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1851 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1852 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1853 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1854 vdp->cram[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1855 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1856 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1857 static debug_val debug_vreg_get(debug_array *array, uint32_t index) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1858 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1859 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1860 return debug_int(vdp->regs[index]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1861 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1862 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1863 static void debug_vreg_set(debug_array *array, uint32_t index, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1864 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1865 vdp_context *vdp = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1866 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1867 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1868 fprintf(stderr, "vdp registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1869 return; |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1870 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1871 vdp_reg_write(vdp, index, ival); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1872 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1873 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1874 static debug_root* find_vdp_root(vdp_context *context) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1875 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1876 debug_root *root = find_root(context); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1877 debug_var *var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1878 var->get = vcounter_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1879 var->ptr = context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1880 root->variables = tern_insert_ptr(root->variables, "vcounter", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1881 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1882 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1883 var->get = hcounter_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1884 var->ptr = context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1885 root->variables = tern_insert_ptr(root->variables, "hcounter", var); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1886 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1887 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1888 var->get = vdp_address_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1889 var->set = vdp_address_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1890 var->ptr = context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1891 root->variables = tern_insert_ptr(root->variables, "address", var); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1892 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1893 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1894 var->get = vdp_cd_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1895 var->set = vdp_cd_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1896 var->ptr = context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1897 root->variables = tern_insert_ptr(root->variables, "cd", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1898 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1899 new_readonly_variable(root, "vram", new_fixed_array(context, debug_vram_get, debug_vram_set, VRAM_SIZE)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1900 new_readonly_variable(root, "vsram", new_fixed_array(context, debug_vsram_get, debug_vsram_set, context->vsram_size)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1901 new_readonly_variable(root, "cram", new_fixed_array(context, debug_cram_get, debug_cram_set, CRAM_SIZE)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1902 new_readonly_variable(root, "reg", new_fixed_array(context, debug_vreg_get, debug_vreg_set, VDP_REGS)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1903 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1904 return root; |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1905 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1906 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1907 static debug_val debug_part1_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1908 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1909 ym2612_context *ym = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1910 return debug_int(ym->part1_regs[index]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1911 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1912 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1913 static void debug_part1_set(debug_array *array, uint32_t index, debug_val val) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1914 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1915 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1916 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1917 fprintf(stderr, "ym2612 registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1918 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1919 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1920 ym2612_context *ym = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1921 uint8_t old_part = ym->selected_part; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1922 uint8_t old_reg = ym->selected_reg; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1923 ym->selected_part = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1924 ym->selected_reg = index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1925 ym_data_write(ym, ival); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1926 ym->selected_part = old_part; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1927 ym->selected_reg = old_reg; |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1928 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1929 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1930 static debug_val debug_part2_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1931 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1932 ym2612_context *ym = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1933 return debug_int(ym->part2_regs[index]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1934 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1935 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1936 static void debug_part2_set(debug_array *array, uint32_t index, debug_val val) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1937 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1938 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1939 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1940 fprintf(stderr, "ym2612 registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1941 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1942 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1943 ym2612_context *ym = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1944 uint8_t old_part = ym->selected_part; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1945 uint8_t old_reg = ym->selected_reg; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1946 ym->selected_part = 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1947 ym->selected_reg = index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1948 ym_data_write(ym, ival); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1949 ym->selected_part = old_part; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1950 ym->selected_reg = old_reg; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1951 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1952 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1953 static debug_root* find_ym2612_root(ym2612_context *context) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1954 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1955 debug_root *root = find_root(context); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1956 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1957 new_readonly_variable(root, "part1", new_fixed_array(context, debug_part1_get, debug_part1_set, YM_REG_END)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1958 new_readonly_variable(root, "part2", new_fixed_array(context, debug_part2_get, debug_part2_set, YM_REG_END)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1959 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1960 return root; |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1961 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1962 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1963 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1964 static debug_val debug_psgfreq_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1965 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1966 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1967 return debug_int(psg->counter_load[index]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1968 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1969 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1970 static void debug_psgfreq_set(debug_array *array, uint32_t index, debug_val val) |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1971 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1972 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1973 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1974 fprintf(stderr, "psg registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1975 return; |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1976 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1977 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1978 psg->counter_load[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1979 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1980 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1981 static debug_val debug_psgcount_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1982 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1983 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1984 return debug_int(psg->counters[index]); |
2360
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1985 } |
053ba4551c62
Expose some more emu state via debugger array mechanism
Michael Pavone <pavone@retrodev.com>
parents:
2359
diff
changeset
|
1986 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1987 static void debug_psgcount_set(debug_array *array, uint32_t index, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1988 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1989 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1990 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1991 fprintf(stderr, "psg registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1992 return; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
1993 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1994 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1995 psg->counters[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1996 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1997 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1998 static debug_val debug_psgvol_get(debug_array *array, uint32_t index) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
1999 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2000 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2001 return debug_int(psg->volume[index]); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2002 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2003 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2004 static void debug_psgvol_set(debug_array *array, uint32_t index, debug_val val) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2005 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2006 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2007 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2008 fprintf(stderr, "psg registers can only be set to integers\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2009 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2010 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2011 psg_context *psg = array->base; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2012 psg->volume[index] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2013 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2014 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2015 debug_root *find_psg_root(psg_context *psg) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2016 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2017 debug_root *root = find_root(psg); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2018 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2019 new_readonly_variable(root, "frequency", new_fixed_array(psg, debug_psgfreq_get, debug_psgfreq_set, 4)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2020 new_readonly_variable(root, "counter", new_fixed_array(psg, debug_psgcount_get, debug_psgcount_set, 4)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2021 new_readonly_variable(root, "volume", new_fixed_array(psg, debug_psgvol_get, debug_psgvol_set, 4)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2022 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2023 return root; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2024 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2025 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2026 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
|
2027 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2028 char *prefix = data; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2029 char * full = alloc_concat(prefix, key); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2030 fprintf(stderr, "\t%s\n", full); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2031 free(full); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2032 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2033 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2034 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
|
2035 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2036 char *cur = text; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2037 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
|
2038 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2039 ++cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2040 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2041 char *name = malloc(cur - text + 1); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2042 memcpy(name, text, cur - text); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2043 name[cur-text] = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2044 uint8_t ret = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2045 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
|
2046 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
|
2047 if (!def) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2048 tern_node *node = prefix_res; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2049 while (node) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2050 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2051 if (node->left || node->right) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2052 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2053 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2054 if (node->el) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2055 node = node->straight.next; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2056 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2057 def = node->straight.value.ptrval; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2058 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2059 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2060 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2061 if (!def && prefix_res) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2062 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
|
2063 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
|
2064 goto cleanup_name; |
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 if (!def) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2068 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
|
2069 goto cleanup_name; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2070 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2071 char *format = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2072 if (*cur == '/') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2073 ++cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2074 text = cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2075 while (*cur && !isspace(*cur)) |
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 ++cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2078 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2079 format = malloc(cur - text + 1); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2080 memcpy(format, text, cur - text); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2081 format[cur - text] = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2082 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2083 int num_args = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2084 command_arg *args = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2085 if (*cur && *cur != '\n') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2086 ++cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2087 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2088 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
|
2089 if (def->raw_args) { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2090 while (*cur && *cur != '\n') |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2091 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2092 ++cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2093 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2094 char *raw_param = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2095 if (cur != text) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2096 raw_param = malloc(cur - text + 1); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2097 memcpy(raw_param, text, cur - text); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2098 raw_param[cur - text] = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2099 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2100 out->raw = raw_param; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2101 out->args = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2102 out->num_args = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2103 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2104 int arg_storage = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2105 if (def->max_args > 0) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2106 arg_storage = def->max_args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2107 } else if (def->max_args) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2108 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
|
2109 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2110 if (arg_storage) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2111 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
|
2112 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2113 while (*text && *text != '\n') |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2114 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2115 char *after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2116 expr *e = parse_expression(text, &after); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2117 if (e) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2118 if (num_args == arg_storage) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2119 if (def->max_args >= 0) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2120 free_expr(e); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2121 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
|
2122 goto cleanup_args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2123 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2124 arg_storage *= 2; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2125 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
|
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 args[num_args].parsed = e; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2129 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
|
2130 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
|
2131 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
|
2132 text = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2133 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2134 goto cleanup_args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2135 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2136 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2137 if (num_args < def->min_args) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2138 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
|
2139 goto cleanup_args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2140 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2141 out->raw = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2142 out->args = args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2143 out->num_args = num_args; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2144 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2145 out->def = def; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2146 out->format = format; |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
2147 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2148 ret = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2149 cleanup_args: |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2150 if (!ret) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2151 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
|
2152 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2153 free_expr(args[i].parsed); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2154 free(args[i].raw); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2155 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2156 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
|
2157 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2158 cleanup_name: |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2159 free(name); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2160 return ret; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2161 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2162 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2163 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
|
2164 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
|
2165 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2166 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
|
2167 { |
e17d99c96c89
Make blocks an 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 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
|
2169 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2170 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
|
2171 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2172 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2173 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
|
2174 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2175 free(cmd->format); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2176 free(cmd->raw); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2177 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
|
2178 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2179 free(cmd->args[i].raw); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2180 free_expr(cmd->args[i].parsed); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2181 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2182 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
|
2183 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
|
2184 free(cmd->args); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2185 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2186 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2187 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
|
2188 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
|
2189 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
|
2190 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
|
2191 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
|
2192 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
|
2193 }; |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2194 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2195 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
|
2196 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2197 ++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
|
2198 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
|
2199 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2200 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
|
2201 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2202 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
|
2203 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
|
2204 #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
|
2205 #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
|
2206 #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
|
2207 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
|
2208 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
|
2209 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
|
2210 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
|
2211 #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
|
2212 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
|
2213 process_events(); |
2302
0343f0d5add0
Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents:
2252
diff
changeset
|
2214 #ifndef IS_LIB |
2252
6a07b13894f7
Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2216
diff
changeset
|
2215 render_update_display(); |
2302
0343f0d5add0
Fix libretro build for real
Michael Pavone <pavone@retrodev.com>
parents:
2252
diff
changeset
|
2216 #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
|
2217 #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
|
2218 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
|
2219 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
|
2220 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
|
2221 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
|
2222 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
|
2223 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2224 #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
|
2225 } 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
|
2226 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2227 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
|
2228 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
|
2229 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
|
2230 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
|
2231 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2232 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
|
2233 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
|
2234 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
|
2235 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2236 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
|
2237 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
|
2238 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
|
2239 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2240 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
|
2241 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
|
2242 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2243 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2244 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
|
2245 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
|
2246 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
|
2247 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2248 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
|
2249 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
|
2250 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
|
2251 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
|
2252 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
|
2253 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2254 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
|
2255 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
|
2256 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
|
2257 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2258 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
|
2259 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2260 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
|
2261 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
|
2262 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
|
2263 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
|
2264 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
|
2265 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
|
2266 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
|
2267 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
|
2268 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
|
2269 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
|
2270 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
|
2271 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2272 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
|
2273 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
|
2274 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
|
2275 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2276 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
|
2277 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
|
2278 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
|
2279 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
|
2280 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2281 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2282 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2283 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
|
2284 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2285 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2286 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
|
2287 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2288 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
|
2289 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
|
2290 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2291 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
|
2292 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
|
2293 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
|
2294 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2295 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2296 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2297 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
|
2298 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2299 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2300 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
|
2301 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2302 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2303 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
|
2304 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
|
2305 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
|
2306 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
|
2307 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
|
2308 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
|
2309 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
|
2310 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2311 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
|
2312 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
|
2313 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2314 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
|
2315 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
|
2316 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
|
2317 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
|
2318 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
|
2319 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
|
2320 } |
2193
d00fb9c6a6a2
Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents:
2191
diff
changeset
|
2321 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
|
2322 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
|
2323 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
|
2324 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
|
2325 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
|
2326 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2327 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
|
2328 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2329 } |
2193
d00fb9c6a6a2
Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents:
2191
diff
changeset
|
2330 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
|
2331 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
|
2332 } else { |
d00fb9c6a6a2
Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents:
2191
diff
changeset
|
2333 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
|
2334 } |
d00fb9c6a6a2
Fix a couple of debugger regressions introduced with changes to support blocks
Michael Pavone <pavone@retrodev.com>
parents:
2191
diff
changeset
|
2335 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
|
2336 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2337 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2338 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
|
2339 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2340 exit(0); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2341 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2342 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2343 typedef struct { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2344 size_t num_commands; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2345 size_t longest_command; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2346 } help_state; |
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 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
|
2349 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2350 command_def *def = val.ptrval; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2351 if (def->visited) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2352 return; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2353 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2354 def->visited = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2355 help_state *state = data; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2356 state->num_commands++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2357 size_t len = strlen(def->usage); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2358 if (len > state->longest_command) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2359 state->longest_command = len; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2360 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2361 } |
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 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
|
2364 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2365 command_def *def = val.ptrval; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2366 def->visited = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2367 } |
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 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
|
2370 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2371 command_def *def = val.ptrval; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2372 if (def->visited) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2373 return; |
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 def->visited = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2376 help_state *state = data; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2377 size_t len = strlen(def->usage); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2378 printf(" %s", def->usage); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2379 while (len < state->longest_command) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2380 putchar(' '); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2381 len++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2382 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2383 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
|
2384 const char *extra_desc = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2385 if (strlen(def->desc) <= remaining) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2386 printf(" - %s\n", def->desc); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2387 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2388 char split[76]; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2389 int split_point = remaining; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2390 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
|
2391 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2392 --split_point; |
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 if (!split_point) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2395 split_point = remaining; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2396 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2397 memcpy(split, def->desc, split_point); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2398 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
|
2399 split[split_point] = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2400 printf(" - %s\n", split); |
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 if (def->names[1]) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2403 fputs(" Aliases: ", stdout); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2404 len = strlen(" Aliases: "); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2405 const char **name = def->names + 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2406 uint8_t first = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2407 while (*name) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2408 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2409 if (first) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2410 first = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2411 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2412 putchar(','); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2413 putchar(' '); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2414 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
|
2415 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2416 fputs(*name, stdout); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2417 len += strlen(*name); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2418 ++name; |
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 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2421 len = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2422 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2423 if (extra_desc) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2424 while (len < state->longest_command + 5) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2425 putchar(' '); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2426 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
|
2427 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2428 fputs(extra_desc, stdout); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2429 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2430 putchar('\n'); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2431 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2432 |
2188
e17d99c96c89
Make blocks an 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 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
|
2434 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2435 help_state state = {0,0}; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2436 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
|
2437 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
|
2438 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
|
2439 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
|
2440 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2441 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2442 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2443 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
|
2444 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2445 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2446 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2447 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2448 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
|
2449 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2450 strcpy(format_str, "%s: %d\n"); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2451 if (format) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2452 switch (format[0]) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2453 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2454 case 'x': |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2455 case 'X': |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2456 case 'd': |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2457 case 'c': |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2458 case 's': |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2459 format_str[5] = format[0]; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2460 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2461 default: |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2462 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
|
2463 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2464 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2465 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2466 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2467 static void do_print(debug_root *root, char *format_str, char *raw, debug_val 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
|
2468 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2469 switch(value.type) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2470 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2471 case DBG_VAL_U32: |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2472 if (format_str[5] == 's') { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2473 char tmp[128]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2474 int j; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2475 uint32_t addr = value.v.u32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2476 for (j = 0; j < sizeof(tmp)-1; j++, addr++) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2477 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2478 uint32_t tmp_addr = addr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2479 root->read_mem(root, &tmp_addr, 'b'); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2480 char c = tmp_addr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2481 if (c < 0x20 || c > 0x7F) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2482 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2483 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2484 tmp[j] = c; |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2485 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2486 tmp[j] = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2487 printf(format_str, raw, tmp); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2488 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2489 printf(format_str, raw, value.v.u32); |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2490 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2491 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2492 case DBG_VAL_F32: { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2493 char tmp = format_str[5]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2494 format_str[5] = 'f'; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2495 printf(format_str, raw, value.v.f32); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2496 format_str[5] = tmp; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2497 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2498 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2499 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2500 } |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2501 |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2502 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
|
2503 { |
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2504 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
|
2505 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
|
2506 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
|
2507 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2508 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
|
2509 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2510 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2511 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2512 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2513 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
|
2514 { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2515 char *fmt = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2516 if (!fmt) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2517 fprintf(stderr, "First parameter to printf must be a string\n"); |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2518 return 1; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2519 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2520 char *cur = fmt; |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2521 char format_str[3] = {'%', 'd', 0}; |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2522 uint32_t cur_param = 1; |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2523 while (*cur) |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2524 { |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2525 if (*cur == '%') { |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2526 switch(cur[1]) |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2527 { |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2528 case 'x': |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2529 case 'X': |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2530 case 'c': |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2531 case 'd': |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2532 case 's': |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2533 case 'f': |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2534 break; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2535 default: |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2536 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
|
2537 return 1; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2538 } |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2539 format_str[1] = cur[1]; |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2540 if (cur_param == cmd->num_args) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2541 fprintf(stderr, "Not enough arguments for format char %c\n", *cur); |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2542 return 1; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2543 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2544 debug_val val = cmd->args[cur_param++].value; |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2545 if (cur[1] == 's') { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2546 if (val.type == DBG_VAL_STRING) { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2547 printf(format_str, get_cstring(val)); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2548 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2549 char tmp[128]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2550 uint32_t address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2551 if (!debug_cast_int(val, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2552 fprintf(stderr, "Format char 's' accepts only integers and strings\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2553 return 1; |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2554 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2555 int j; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2556 for (j = 0; j < sizeof(tmp)-1; j++, address++) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2557 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2558 uint32_t addr = address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2559 root->read_mem(root, &addr, 'b'); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2560 char c = addr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2561 if (c < 0x20 || c > 0x7F) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2562 break; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2563 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2564 tmp[j] = c; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2565 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2566 tmp[j] = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2567 printf(format_str, tmp); |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2568 } |
2363
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2569 } else if (cur[1] == 'f') { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2570 float fval; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2571 if (!debug_cast_float(val, &fval)) { |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2572 fprintf(stderr, "Format char '%c' only accepts floats\n", cur[1]); |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2573 return 1; |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2574 } |
b865f33fd47e
Basic float support in debug language
Michael Pavone <pavone@retrodev.com>
parents:
2362
diff
changeset
|
2575 printf(format_str, fval); |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2576 } else { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2577 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2578 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2579 fprintf(stderr, "Format char '%c' only accepts integers\n", cur[1]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2580 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2581 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2582 printf(format_str, ival); |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2583 } |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2584 cur += 2; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2585 } else { |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2586 putchar(*cur); |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2587 ++cur; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2588 } |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2589 } |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2590 return 1; |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2591 } |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
2592 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2593 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
|
2594 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2595 cmd_print(root, cmd); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2596 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
|
2597 ndisp->next = root->displays; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2598 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
|
2599 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
|
2600 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
|
2601 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
|
2602 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
|
2603 cmd->num_args = 0; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2604 root->displays = ndisp; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2605 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
|
2606 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2607 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2608 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2609 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
|
2610 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2611 disp_def **cur = &root->displays; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2612 uint32_t index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2613 if (!debug_cast_int(cmd->args[0].value, &index)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2614 fprintf(stderr, "Argument to deletedisplay must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2615 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2616 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2617 while (*cur) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2618 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2619 if ((*cur)->index == index) { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2620 disp_def *del_disp = *cur; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2621 *cur = del_disp->next; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2622 free(del_disp->format); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2623 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
|
2624 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2625 free(del_disp->args[i].raw); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2626 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
|
2627 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2628 free(del_disp->args); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2629 free(del_disp); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2630 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2631 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2632 cur = &(*cur)->next; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2633 } |
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 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2636 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2637 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2638 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
|
2639 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2640 if (current_system->soft_reset) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2641 current_system->soft_reset(current_system); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2642 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2643 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2644 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
|
2645 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2646 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2647 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2648 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2649 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
|
2650 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2651 uint32_t index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2652 if (!debug_cast_int(cmd->args[0].value, &index)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2653 fprintf(stderr, "Argument to commands must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2654 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2655 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2656 bp_def **target = find_breakpoint_idx(&root->breakpoints, index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2657 if (!target) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2658 fprintf(stderr, "Breakpoint %d does not exist!\n", index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2659 return 1; |
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 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
|
2662 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2663 free_parsed_command((*target)->commands + i); |
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 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
|
2666 (*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
|
2667 (*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
|
2668 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
|
2669 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
|
2670 return 1; |
2178
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 |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2673 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
|
2674 { |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2675 uint8_t debugging = 1; |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2676 for (int i = 0; i < block->num_commands && debugging; i++) |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2677 { |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2678 debugging = run_command(root, block->commands + i); |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2679 } |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2680 return debugging; |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2681 } |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2682 |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2683 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
|
2684 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2685 return execute_block(root, debug_cast_bool(cmd->args[0].value) ? &cmd->block : &cmd->else_block); |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2686 } |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2687 |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2688 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
|
2689 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2690 if (!debug_cast_bool(cmd->args[0].value)) { |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2691 return execute_block(root, &cmd->else_block); |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2692 } |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2693 int debugging = 1; |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2694 do { |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2695 debugging = execute_block(root, &cmd->block) && debugging; |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2696 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
|
2697 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
|
2698 return 1; |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2699 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2700 } while (debug_cast_bool(cmd->args[0].value)); |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2701 return debugging; |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2702 } |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
2703 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2704 const char *expr_type_names[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2705 "EXPR_NONE", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2706 "EXPR_SCALAR", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2707 "EXPR_UNARY", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2708 "EXPR_BINARY", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2709 "EXPR_SIZE", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2710 "EXPR_MEM" |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2711 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2712 |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2713 static uint8_t cmd_function(debug_root *root, parsed_command *cmd) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2714 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2715 debug_root *set_root = root; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2716 expr *set_expr = cmd->args[0].parsed; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2717 while (set_expr->type == EXPR_NAMESPACE) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2718 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2719 set_root = tern_find_ptr(set_root->other_roots, set_expr->op.v.str); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2720 if (!set_root) { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2721 fprintf(stderr, "%s is not a valid namespace\n", set_expr->op.v.str); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2722 return 1; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2723 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2724 set_expr = set_expr->left; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2725 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2726 if (set_expr->type != EXPR_SCALAR || set_expr->op.type != TOKEN_NAME) { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2727 fprintf(stderr, "Arguments to function must be names, bug argument 0 is %s\n", expr_type_names[set_expr->type]); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2728 return 1; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2729 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2730 debug_var *var = tern_find_ptr(set_root->variables, set_expr->op.v.str); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2731 if (var) { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2732 fprintf(stderr, "%s is already defined\n", set_expr->op.v.str); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2733 return 1; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2734 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2735 for (uint32_t i = 1; i < cmd->num_args; i++) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2736 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2737 if (cmd->args[i].parsed->type != EXPR_SCALAR || cmd->args[i].parsed->op.type != TOKEN_NAME) { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2738 fprintf(stderr, "Arguments to function must be names, bug argument %d is %s\n", i, expr_type_names[cmd->args[i].parsed->type]); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2739 return 1; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2740 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2741 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2742 char **args = calloc(cmd->num_args - 1, sizeof(char *)); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2743 for (uint32_t i = 1; i < cmd->num_args; i++) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2744 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2745 args[i - 1] = cmd->args[i].parsed->op.v.str; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2746 cmd->args[i].parsed->op.v.str = NULL; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2747 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2748 new_readonly_variable(set_root, set_expr->op.v.str, new_user_func(&cmd->block, args, cmd->num_args - 1)); |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2749 cmd->block.commands = NULL; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2750 cmd->block.num_commands = 0; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2751 return 1; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2752 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2753 |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2754 static uint8_t cmd_return(debug_root *root, parsed_command *cmd) |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2755 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2756 root->retval = cmd->args[0].value; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2757 return 0; |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2758 } |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
2759 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2760 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
|
2761 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2762 char *name = NULL; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2763 char size = 0; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2764 debug_root *set_root = root; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2765 expr *set_expr = cmd->args[0].parsed; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2766 while (set_expr->type == EXPR_NAMESPACE) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2767 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2768 set_root = tern_find_ptr(set_root->other_roots, set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2769 if (!set_root) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2770 fprintf(stderr, "%s is not a valid namespace\n", set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2771 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2772 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2773 set_expr = set_expr->left; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2774 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2775 debug_val address; |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2776 debug_array *array = NULL; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2777 switch (set_expr->type) |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2778 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2779 case EXPR_SCALAR: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2780 if (set_expr->op.type == TOKEN_NAME) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2781 name = set_expr->op.v.str; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2782 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2783 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
|
2784 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2785 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2786 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2787 case EXPR_SIZE: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2788 size = set_expr->op.v.op[0]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2789 if (set_expr->left->op.type == TOKEN_NAME) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2790 name = set_expr->left->op.v.str; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2791 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2792 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
|
2793 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2794 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2795 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2796 case EXPR_MEM: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2797 size = set_expr->op.v.op[0]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2798 if (!eval_expr(root, set_expr->left, &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
|
2799 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
|
2800 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2801 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2802 if (address.type != DBG_VAL_U32) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2803 fprintf(stderr, "Index in array expression must be integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2804 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2805 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2806 if (set_expr->right) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2807 debug_val right; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2808 if (!eval_expr(root, set_expr->right, &right)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2809 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2810 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2811 array = get_array(right); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2812 if (!array) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2813 fprintf(stderr, "%s does not refer to an array\n", cmd->args[0].raw); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2814 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2815 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2816 if (!array->set) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2817 fprintf(stderr, "Array %s is read-only\n", set_expr->right->op.v.str); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2818 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2819 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2820 if (address.v.u32 >= array->size) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
2821 fprintf(stderr, "Address $%X is out of bounds for array %s\n", address.v.u32, set_expr->right->op.v.str); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2822 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2823 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2824 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2825 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2826 default: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2827 fprintf(stderr, "First argument to set must be a name or memory expression, got %s\n", expr_type_names[set_expr->type]); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2828 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2829 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2830 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
|
2831 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
|
2832 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2833 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2834 debug_val value = cmd->args[1].value; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2835 if (name) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2836 debug_var *var = tern_find_ptr(set_root->variables, name); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2837 if (!var) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2838 fprintf(stderr, "%s is not defined\n", name); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2839 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2840 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2841 if (!var->set) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2842 fprintf(stderr, "%s is read-only\n", name); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2843 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2844 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2845 if (size && size != 'l') { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2846 debug_val old = var->get(var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2847 if (size == 'b') { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2848 old.v.u32 &= 0xFFFFFF00; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2849 value.v.u32 &= 0xFF; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2850 value.v.u32 |= old.v.u32; |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2851 } else { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2852 old.v.u32 &= 0xFFFF0000; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2853 value.v.u32 &= 0xFFFF; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2854 value.v.u32 |= old.v.u32; |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2855 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2856 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2857 var->set(var, value); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2858 } else if (array) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2859 array->set(array, address.v.u32, value); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2860 } else if (!root->write_mem(root, address.v.u32, value.v.u32, size)) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
2861 fprintf(stderr, "Failed to write to address $%X\n", address.v.u32); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2862 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2863 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2864 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
2865 |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2866 static uint8_t cmd_variable(debug_root *root, parsed_command *cmd) |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2867 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2868 debug_root *set_root = root; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2869 expr *set_expr = cmd->args[0].parsed; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2870 while (set_expr->type == EXPR_NAMESPACE) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2871 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2872 set_root = tern_find_ptr(set_root->other_roots, set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2873 if (!set_root) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2874 fprintf(stderr, "%s is not a valid namespace\n", set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2875 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2876 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2877 set_expr = set_expr->left; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2878 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2879 if (set_expr->type != EXPR_SCALAR || set_expr->op.type != TOKEN_NAME) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2880 fprintf(stderr, "First argument to variable must be a name, got %s\n", expr_type_names[set_expr->type]); |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2881 return 1; |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2882 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2883 debug_var *var = tern_find_ptr(set_root->variables, set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2884 if (var) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2885 fprintf(stderr, "%s is already defined\n", set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2886 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2887 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2888 debug_val value; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2889 value.type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2890 value.v.u32 = 0; |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2891 if (cmd->num_args > 1) { |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2892 if (!eval_expr(root, cmd->args[1].parsed, &cmd->args[1].value)) { |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2893 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw); |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2894 return 1; |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2895 } |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2896 value = cmd->args[1].value; |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2897 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2898 new_user_variable(set_root, set_expr->op.v.str, value); |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2899 return 1; |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2900 } |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
2901 |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2902 static uint8_t cmd_array(debug_root *root, parsed_command *cmd) |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2903 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2904 debug_root *set_root = root; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2905 expr *set_expr = cmd->args[0].parsed; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2906 while (set_expr->type == EXPR_NAMESPACE) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2907 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2908 set_root = tern_find_ptr(set_root->other_roots, set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2909 if (!set_root) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2910 fprintf(stderr, "%s is not a valid namespace\n", set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2911 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2912 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2913 set_expr = set_expr->left; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2914 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2915 if (set_expr->type != EXPR_SCALAR || set_expr->op.type != TOKEN_NAME) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2916 fprintf(stderr, "First argument to array must be a name, got %s\n", expr_type_names[set_expr->type]); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2917 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2918 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2919 debug_var *var = tern_find_ptr(set_root->variables, set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2920 debug_array *array; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2921 if (var) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2922 debug_val val = var->get(var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2923 array = get_array(val); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2924 if (!array) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2925 fprintf(stderr, "%s is already defined as a non-array value\n", set_expr->op.v.str); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2926 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2927 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2928 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2929 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2930 var->get = user_var_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2931 var->set = user_var_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2932 var->val = new_user_array(cmd->num_args - 1); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2933 set_root->variables = tern_insert_ptr(set_root->variables, set_expr->op.v.str, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2934 array = get_array(var->val); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2935 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2936 if (array->set == user_array_set) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2937 array->size = cmd->num_args - 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2938 if (array->storage < array->size) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2939 array->storage = array->size; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2940 array->base = realloc(array->base, sizeof(debug_val) * array->storage); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2941 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2942 } |
2367
48cc69b4c358
Add some more builtin functions to debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2366
diff
changeset
|
2943 for (uint32_t i = 1; i < cmd->num_args && i <= array->size; i++) |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2944 { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2945 if (!eval_expr(root, cmd->args[i].parsed, &cmd->args[i].value)) { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2946 fprintf(stderr, "Failed to eval %s\n", cmd->args[i].raw); |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2947 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2948 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2949 array->set(array, i - 1, cmd->args[i].value); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2950 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2951 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2952 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2953 |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2954 static uint8_t cmd_append(debug_root *root, parsed_command *cmd) |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2955 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2956 debug_array *array = get_array(cmd->args[0].value); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2957 if (!array) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2958 fprintf(stderr, "%s is not an array\n", cmd->args[0].raw); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2959 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2960 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2961 if (!array->append) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2962 fprintf(stderr, "Array %s doesn't support appending\n", cmd->args[0].raw); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2963 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2964 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2965 array->append(array, cmd->args[1].value); |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2966 return 1; |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2967 } |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
2968 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2969 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
|
2970 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2971 uint32_t frames; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2972 if (!debug_cast_int(cmd->args[0].value, &frames)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2973 fprintf(stderr, "Argument to frames must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2974 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2975 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
2976 current_system->enter_debugger_frames = frames; |
2179
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
2977 return 0; |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
2978 } |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
2979 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2980 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
|
2981 { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2982 char *bind = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2983 if (!bind) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2984 fprintf(stderr, "Argument to bindup must be a string\n"); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2985 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2986 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2987 if (!bind_up(bind)) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2988 fprintf(stderr, "%s is not a valid binding name\n", bind); |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
2989 } |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
2990 return 1; |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
2991 } |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
2992 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
2993 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
|
2994 { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2995 char *bind = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2996 if (!bind) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2997 fprintf(stderr, "Argument to binddown must be a string\n"); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2998 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
2999 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3000 if (!bind_down(bind)) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3001 fprintf(stderr, "%s is not a valid binding name\n", bind); |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
3002 } |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
3003 return 1; |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
3004 } |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
3005 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3006 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
|
3007 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3008 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
|
3009 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
|
3010 return 1; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3011 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3012 uint32_t index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3013 if (!debug_cast_int(cmd->args[0].value, &index)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3014 fprintf(stderr, "First argument to condition must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3015 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3016 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3017 bp_def **target = find_breakpoint_idx(&root->breakpoints, index); |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3018 if (!*target) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3019 fprintf(stderr, "Failed to find breakpoint %u\n", index); |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3020 return 1; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3021 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3022 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
|
3023 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
|
3024 (*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
|
3025 cmd->args[1].parsed = NULL; |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3026 } else { |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3027 (*target)->condition = NULL; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3028 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3029 return 1; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3030 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
3031 |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3032 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
|
3033 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3034 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
|
3035 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
|
3036 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
|
3037 *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
|
3038 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3039 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3040 |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3041 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
|
3042 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3043 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
|
3044 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
|
3045 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
|
3046 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
|
3047 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3048 putchar(' '); |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3049 len++; |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3050 } |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
3051 printf("$%X\n", (uint32_t)val.intval); |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3052 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3053 |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3054 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
|
3055 { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3056 if (cmd->num_args) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3057 char *filename = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3058 if (!filename) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3059 fprintf(stderr, "Argument to symbols must be a string if provided\n"); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3060 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3061 } |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3062 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
|
3063 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
|
3064 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
|
3065 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
|
3066 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3067 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
|
3068 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
|
3069 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3070 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
|
3071 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
|
3072 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
|
3073 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
|
3074 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
|
3075 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
|
3076 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
|
3077 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
|
3078 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
|
3079 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3080 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3081 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3082 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3083 } else { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3084 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
|
3085 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
|
3086 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
|
3087 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
|
3088 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3089 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
|
3090 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
3091 |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3092 static uint8_t cmd_save(debug_root *root, parsed_command *cmd) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3093 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3094 char size = cmd->format ? cmd->format[0] : 'b'; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3095 if (size != 'b' && size != 'w' && size != 'l') { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3096 fprintf(stderr, "Invalid size %s\n", cmd->format); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3097 return 1; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3098 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3099 if (!eval_expr(root, cmd->args[0].parsed, &cmd->args[0].value)) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3100 fprintf(stderr, "Failed to eval %s\n", cmd->args[0].raw); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3101 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3102 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3103 char *fname = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3104 if (!fname) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3105 fprintf(stderr, "First argument to save must be a string\n"); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3106 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3107 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3108 FILE *f = fopen(fname, "wb"); |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3109 if (!f) { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3110 fprintf(stderr, "Failed to open %s for writing\n", fname); |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3111 return 1; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3112 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3113 uint32_t start = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3114 debug_val val; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3115 debug_array * arr = NULL; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3116 if (cmd->args[1].parsed->type == EXPR_MEM) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3117 |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3118 if (!eval_expr(root, cmd->args[1].parsed->left, &val)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3119 fprintf(stderr, "Failed to eval start index\n"); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3120 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3121 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3122 if (!debug_cast_int(val, &start)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3123 fprintf(stderr, "Start index must evaluate to integer\n"); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3124 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3125 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3126 if (cmd->args[1].parsed->right) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3127 if (!eval_expr(root, cmd->args[1].parsed->right, &val)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3128 fprintf(stderr, "Failed to eval array name in argument %s\n", cmd->args[1].raw); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3129 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3130 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3131 arr = get_array(val); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3132 if (!arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3133 fprintf(stderr, "Name in argument %s did not evaluate to an array\n", cmd->args[1].raw); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3134 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3135 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3136 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3137 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3138 if (!eval_expr(root, cmd->args[1].parsed, &val)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3139 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3140 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3141 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3142 arr = get_array(val); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3143 if (!arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3144 fprintf(stderr, "Argument %s did not evaluate to an array\n", cmd->args[1].raw); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3145 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3146 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3147 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3148 uint32_t count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3149 if (cmd->num_args > 2) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3150 if (!eval_expr(root, cmd->args[2].parsed, &val)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3151 fprintf(stderr, "Failed to eval %s\n", cmd->args[2].raw); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3152 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3153 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3154 if (!debug_cast_int(val, &count)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3155 fprintf(stderr, "Count must evaluate to integer\n"); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3156 goto cleanup; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3157 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3158 } else if (arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3159 count = arr->size < start ? 0 : arr->size - start; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3160 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3161 count = root->chunk_end(root, start) - start; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3162 if (size == 'l') { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3163 count /= 4; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3164 } else if (size == 'w') { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3165 count /= 2; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3166 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3167 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3168 union { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3169 uint8_t b[1024]; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3170 uint16_t w[512]; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3171 uint32_t l[256]; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3172 } buffer; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3173 uint32_t cur = start; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3174 if (size == 'l') { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3175 while (count) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3176 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3177 uint32_t n = count < 256 ? count : 256; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3178 count -= n; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3179 for (uint32_t i = 0; i < n ; i++) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3180 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3181 if (arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3182 val = arr->get(arr, cur++); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3183 if (!debug_cast_int(val, buffer.l + i)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3184 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3185 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3186 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3187 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3188 buffer.l[i] = cur; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3189 cur += 4; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3190 if (!root->read_mem(root, buffer.l + i, 'l')) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3191 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3192 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3193 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3194 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3195 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3196 fwrite(buffer.l, sizeof(uint32_t), n, f); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3197 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3198 } else if (size == 'w') { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3199 while (count) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3200 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3201 uint32_t n = count < 512 ? count : 512; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3202 count -= n; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3203 uint32_t tmp; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3204 for (uint32_t i = 0; i < n ; i++) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3205 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3206 if (arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3207 val = arr->get(arr, cur++); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3208 if (!debug_cast_int(val, &tmp)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3209 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3210 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3211 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3212 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3213 tmp = cur; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3214 cur += 2; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3215 if (!root->read_mem(root, &tmp, 'w')) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3216 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3217 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3218 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3219 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3220 buffer.w[i] = tmp; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3221 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3222 fwrite(buffer.w, sizeof(uint16_t), n, f); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3223 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3224 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3225 while (count) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3226 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3227 uint32_t n = count < 1024 ? count : 1024; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3228 count -= n; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3229 uint32_t tmp; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3230 for (uint32_t i = 0; i < n ; i++) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3231 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3232 if (arr) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3233 val = arr->get(arr, cur++); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3234 if (!debug_cast_int(val, &tmp)) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3235 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3236 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3237 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3238 } else { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3239 tmp = cur++; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3240 if (!root->read_mem(root, &tmp, 'b')) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3241 n = i; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3242 count = 0; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3243 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3244 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3245 buffer.b[i] = tmp; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3246 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3247 fwrite(buffer.b, sizeof(uint8_t), n, f); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3248 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3249 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3250 cleanup: |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3251 fclose(f); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3252 return 1; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3253 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
3254 |
2394
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3255 static uint8_t cmd_load(debug_root *root, parsed_command *cmd) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3256 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3257 char size = cmd->format ? cmd->format[0] : 'b'; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3258 if (size != 'b' && size != 'w' && size != 'l') { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3259 fprintf(stderr, "Invalid size %s\n", cmd->format); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3260 return 1; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3261 } |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3262 if (!eval_expr(root, cmd->args[0].parsed, &cmd->args[0].value)) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3263 fprintf(stderr, "Failed to eval %s\n", cmd->args[0].raw); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3264 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3265 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3266 char *fname = get_cstring(cmd->args[0].value); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3267 if (!fname) { |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3268 fprintf(stderr, "First argument to load must be a string\n"); |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3269 return 1; |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3270 } |
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3271 FILE *f = fopen(fname, "rb"); |
2394
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3272 if (!f) { |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3273 fprintf(stderr, "Failed to open %s for reading\n", fname); |
2394
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3274 return 1; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3275 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3276 uint32_t start = 0; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3277 debug_val val; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3278 debug_array * arr = NULL; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3279 if (cmd->args[1].parsed->type == EXPR_MEM) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3280 |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3281 if (!eval_expr(root, cmd->args[1].parsed->left, &val)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3282 fprintf(stderr, "Failed to eval start index\n"); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3283 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3284 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3285 if (!debug_cast_int(val, &start)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3286 fprintf(stderr, "Start index must evaluate to integer\n"); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3287 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3288 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3289 if (cmd->args[1].parsed->right) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3290 if (!eval_expr(root, cmd->args[1].parsed->right, &val)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3291 fprintf(stderr, "Failed to eval array name in argument %s\n", cmd->args[1].raw); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3292 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3293 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3294 arr = get_array(val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3295 if (!arr) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3296 fprintf(stderr, "Name in argument %s did not evaluate to an array\n", cmd->args[1].raw); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3297 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3298 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3299 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3300 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3301 if (!eval_expr(root, cmd->args[1].parsed, &val)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3302 fprintf(stderr, "Failed to eval %s\n", cmd->args[1].raw); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3303 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3304 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3305 arr = get_array(val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3306 if (!arr) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3307 fprintf(stderr, "Argument %s did not evaluate to an array\n", cmd->args[1].raw); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3308 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3309 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3310 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3311 uint32_t count = 0; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3312 uint8_t has_count = 0; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3313 if (cmd->num_args > 2) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3314 if (!eval_expr(root, cmd->args[2].parsed, &val)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3315 fprintf(stderr, "Failed to eval %s\n", cmd->args[2].raw); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3316 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3317 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3318 if (!debug_cast_int(val, &count)) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3319 fprintf(stderr, "Count must evaluate to integer\n"); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3320 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3321 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3322 has_count = 1; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3323 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3324 union { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3325 uint8_t b[1024]; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3326 uint16_t w[512]; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3327 uint32_t l[256]; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3328 } buffer; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3329 uint32_t cur = start; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3330 if (size == 'l') { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3331 while (count || !has_count) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3332 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3333 uint32_t n = (has_count && count < 256) ? count : 256; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3334 count -= n; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3335 n = fread(buffer.l, sizeof(uint32_t), n, f); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3336 if (!n) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3337 break; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3338 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3339 for (uint32_t i = 0; i < n ; i++) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3340 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3341 if (arr) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3342 val = debug_int(buffer.l[i]); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3343 if (cur >= arr->size) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3344 if (arr->append) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3345 arr->append(arr, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3346 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3347 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3348 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3349 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3350 arr->set(arr, cur, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3351 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3352 cur++; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3353 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3354 if (!root->write_mem(root, cur, buffer.l[i], 'l')) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3355 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3356 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3357 cur += 4; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3358 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3359 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3360 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3361 } else if (size == 'w') { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3362 while (count || !has_count) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3363 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3364 uint32_t n = (has_count && count < 512) ? count : 512; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3365 count -= n; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3366 n = fread(buffer.w, sizeof(uint16_t), n, f); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3367 if (!n) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3368 break; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3369 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3370 for (uint32_t i = 0; i < n ; i++) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3371 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3372 if (arr) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3373 val = debug_int(buffer.w[i]); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3374 if (cur >= arr->size) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3375 if (arr->append) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3376 arr->append(arr, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3377 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3378 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3379 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3380 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3381 arr->set(arr, cur, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3382 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3383 cur++; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3384 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3385 if (!root->write_mem(root, cur, buffer.w[i], 'w')) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3386 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3387 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3388 cur += 2; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3389 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3390 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3391 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3392 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3393 while (count || !has_count) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3394 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3395 uint32_t n = (has_count && count < 1024) ? count : 1024; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3396 count -= n; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3397 n = fread(buffer.b, sizeof(uint8_t), n, f); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3398 if (!n) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3399 break; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3400 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3401 for (uint32_t i = 0; i < n ; i++) |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3402 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3403 if (arr) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3404 val = debug_int(buffer.b[i]); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3405 if (cur >= arr->size) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3406 if (arr->append) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3407 arr->append(arr, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3408 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3409 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3410 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3411 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3412 arr->set(arr, cur, val); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3413 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3414 } else { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3415 if (!root->write_mem(root, cur, buffer.b[i], 'b')) { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3416 goto cleanup; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3417 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3418 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3419 cur++; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3420 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3421 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3422 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3423 cleanup: |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3424 fclose(f); |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3425 return 1; |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3426 } |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
3427 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3428 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
|
3429 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3430 uint32_t index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3431 if (!debug_cast_int(cmd->args[0].value, &index)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3432 fprintf(stderr, "Argument to delete must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3433 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3434 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3435 bp_def **this_bp = find_breakpoint_idx(&root->breakpoints, index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3436 if (!*this_bp) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3437 fprintf(stderr, "Breakpoint %d does not exist\n", index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3438 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3439 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3440 bp_def *tmp = *this_bp; |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3441 if (tmp->type == BP_TYPE_CPU) { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3442 remove_breakpoint(root->cpu_context, tmp->address); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3443 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3444 *this_bp = (*this_bp)->next; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3445 if (tmp->commands) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3446 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
|
3447 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3448 free_parsed_command(tmp->commands + i); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3449 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3450 free(tmp->commands); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3451 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3452 free(tmp); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3453 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3454 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3455 |
2188
e17d99c96c89
Make blocks an 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 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
|
3457 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3458 uint32_t address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3459 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3460 fprintf(stderr, "Argument to breakpoint must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3461 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3462 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3463 insert_breakpoint(root->cpu_context, address, debugger); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3464 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
|
3465 new_bp->next = root->breakpoints; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3466 new_bp->address = address; |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3467 new_bp->mask = 0xFFFFFF; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3468 new_bp->index = root->bp_index++; |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3469 new_bp->type = BP_TYPE_CPU; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3470 root->breakpoints = new_bp; |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
3471 printf("68K Breakpoint %d set at $%X\n", new_bp->index, address); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3472 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3473 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3474 |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3475 static void on_vdp_reg_write(vdp_context *context, uint16_t reg, uint16_t value) |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3476 { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3477 value &= 0xFF; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3478 if (context->regs[reg] == value) { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3479 return; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3480 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3481 genesis_context *gen = (genesis_context *)context->system; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3482 debug_root *root = find_m68k_root(gen->m68k); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3483 bp_def **this_bp = find_breakpoint(&root->breakpoints, reg, BP_TYPE_VDPREG); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3484 int debugging = 1; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3485 if (*this_bp) { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3486 if ((*this_bp)->condition) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3487 debug_val condres; |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3488 if (eval_expr(root, (*this_bp)->condition, &condres)) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3489 if (!condres.v.u32) { |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3490 return; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3491 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3492 } else { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3493 fprintf(stderr, "Failed to eval condition for VDP Register Breakpoint %u\n", (*this_bp)->index); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3494 free_expr((*this_bp)->condition); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3495 (*this_bp)->condition = NULL; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3496 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3497 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3498 for (uint32_t i = 0; debugging && i < (*this_bp)->num_commands; i++) |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3499 { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3500 debugging = run_command(root, (*this_bp)->commands + i); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3501 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3502 if (debugging) { |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
3503 printf("VDP Register Breakpoint %d hit on register write $%X - Old: $%X, New: $%X\n", (*this_bp)->index, reg, context->regs[reg], value); |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3504 gen->header.enter_debugger = 1; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3505 if (gen->m68k->sync_cycle > gen->m68k->current_cycle + 1) { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3506 gen->m68k->sync_cycle = gen->m68k->current_cycle + 1; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3507 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3508 if (gen->m68k->target_cycle > gen->m68k->sync_cycle) { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3509 gen->m68k->target_cycle = gen->m68k->sync_cycle; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3510 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3511 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3512 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3513 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3514 |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3515 static uint8_t cmd_vdp_reg_break(debug_root *root, parsed_command *cmd) |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3516 { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3517 bp_def *new_bp = calloc(1, sizeof(bp_def)); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3518 new_bp->next = root->breakpoints; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3519 if (cmd->num_args) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3520 if (!debug_cast_int(cmd->args[0].value, &new_bp->address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3521 fprintf(stderr, "Arguments to vdpregbreak must be integers if provided\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3522 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3523 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3524 if (cmd->num_args > 1) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3525 if (!debug_cast_int(cmd->args[1].value, &new_bp->mask)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3526 fprintf(stderr, "Arguments to vdpregbreak must be integers if provided\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3527 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3528 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3529 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3530 new_bp->mask = 0xFF; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3531 } |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3532 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3533 new_bp->index = root->bp_index++; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3534 new_bp->type = BP_TYPE_VDPREG; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3535 root->breakpoints = new_bp; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3536 m68k_context *m68k = root->cpu_context; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3537 genesis_context *gen = m68k->system; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3538 gen->vdp->reg_hook = on_vdp_reg_write; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3539 printf("VDP Register Breakpoint %d set\n", new_bp->index); |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3540 return 1; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3541 } |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
3542 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3543 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
|
3544 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3545 uint32_t address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3546 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3547 fprintf(stderr, "Argument to advance must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3548 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3549 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3550 insert_breakpoint(root->cpu_context, address, debugger); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3551 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3552 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3553 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3554 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
|
3555 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3556 m68kinst *inst = root->inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3557 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3558 uint32_t after = root->after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3559 if (inst->op == M68K_RTS) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3560 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
|
3561 } 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
|
3562 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
|
3563 } else if(m68k_is_branch(inst)) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3564 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
|
3565 root->branch_f = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3566 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
|
3567 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
|
3568 } else if(inst->op == M68K_DBCC) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3569 if (inst->extra.cond == COND_FALSE) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3570 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
|
3571 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
|
3572 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3573 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3574 root->branch_t = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3575 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
|
3576 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
|
3577 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3578 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3579 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
|
3580 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3581 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3582 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
|
3583 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3584 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3585 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3586 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
|
3587 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3588 m68kinst *inst = root->inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3589 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3590 uint32_t after = root->after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3591 if (inst->op == M68K_RTS) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3592 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
|
3593 } 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
|
3594 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
|
3595 } 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
|
3596 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
|
3597 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
|
3598 if (root->branch_t < after) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3599 root->branch_t = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3600 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3601 root->branch_f = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3602 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
|
3603 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3604 } else if(inst->op == M68K_DBCC) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3605 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
|
3606 if (target > after) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3607 if (inst->extra.cond == COND_FALSE) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3608 after = target; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3609 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3610 root->branch_f = target; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3611 root->branch_t = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3612 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
|
3613 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3614 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3615 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3616 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
|
3617 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3618 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3619 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
|
3620 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3621 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3622 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3623 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
|
3624 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3625 m68kinst *inst = root->inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3626 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3627 uint32_t after = root->after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3628 if (inst->op == M68K_RTS) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3629 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
|
3630 } 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
|
3631 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
|
3632 } 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
|
3633 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
|
3634 root->branch_f = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3635 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
|
3636 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
|
3637 } else if(inst->op == M68K_DBCC) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3638 if ( inst->extra.cond == COND_FALSE) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3639 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
|
3640 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
|
3641 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3642 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3643 root->branch_t = after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3644 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
|
3645 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
|
3646 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3647 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3648 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
|
3649 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3650 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3651 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
|
3652 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3653 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3654 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3655 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
|
3656 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3657 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3658 uint32_t stack = context->aregs[7]; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3659 uint8_t non_adr_count = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3660 do { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3661 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
|
3662 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
|
3663 if (bt_address) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3664 stack += 4; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3665 non_adr_count = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3666 m68kinst inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3667 char buf[128]; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3668 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
|
3669 m68k_disasm(&inst, buf); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3670 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
|
3671 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3672 //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
|
3673 stack += 2; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3674 non_adr_count++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3675 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3676 //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
|
3677 } while (stack && non_adr_count < 6); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3678 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3679 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3680 |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3681 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
|
3682 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3683 m68k_context *context = root->cpu_context; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3684 uint32_t address = root->address; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3685 if (cmd->num_args) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3686 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3687 fprintf(stderr, "Argument to disassemble must be an integer if provided\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3688 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3689 } |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3690 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3691 char disasm_buf[1024]; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3692 m68kinst inst; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3693 do { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3694 label_def *def = find_label(root->disasm, address); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3695 if (def) { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3696 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
|
3697 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3698 printf("%s:\n", def->labels[i]); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3699 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3700 } |
2252
6a07b13894f7
Fix input processing while waiting for console input in debugger
Michael Pavone <pavone@retrodev.com>
parents:
2216
diff
changeset
|
3701 |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3702 address = m68k_decode(m68k_instruction_fetch, context, &inst, address); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3703 m68k_disasm_labels(&inst, disasm_buf, root->disasm); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3704 printf("\t%s\n", disasm_buf); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3705 } while(!m68k_is_terminal(&inst)); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3706 return 1; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3707 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
3708 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3709 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
|
3710 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3711 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3712 genesis_context * gen = context->system; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3713 vdp_print_sprite_table(gen->vdp); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3714 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3715 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3716 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3717 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
|
3718 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3719 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3720 genesis_context * gen = context->system; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3721 vdp_print_reg_explain(gen->vdp); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3722 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3723 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3724 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3725 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
|
3726 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3727 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3728 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
|
3729 if (cmd->num_args) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3730 ym_print_channel_info(gen->ym, cmd->args[0].value.v.u32 - 1); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3731 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3732 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
|
3733 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
|
3734 } |
2173
894c7873a2b1
Consume all expressions in debugger print command
Michael Pavone <pavone@retrodev.com>
parents:
2172
diff
changeset
|
3735 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3736 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3737 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3738 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3739 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
|
3740 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3741 m68k_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3742 genesis_context * gen = context->system; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3743 ym_print_timer_info(gen->ym); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3744 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3745 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3746 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3747 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
|
3748 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3749 char *param = cmd->raw; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3750 while (param && *param && isblank(*param)) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3751 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3752 ++param; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3753 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3754 m68k_context *m68k = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3755 genesis_context *gen = m68k->system; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3756 segacd_context *cd = gen->expansion; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3757 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
|
3758 parsed_command cmd = {0}; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3759 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
|
3760 if (!sub_root) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3761 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
|
3762 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3763 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3764 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
|
3765 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3766 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3767 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
|
3768 free_parsed_command(&cmd); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3769 return ret; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3770 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3771 cd->enter_debugger = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3772 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3773 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3774 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3775 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3776 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
|
3777 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3778 char *param = cmd->raw; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3779 while (param && *param && isblank(*param)) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3780 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3781 ++param; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3782 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3783 m68k_context *m68k = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3784 segacd_context *cd = m68k->system; |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
3785 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3786 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
|
3787 parsed_command cmd = {0}; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3788 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
|
3789 if (!main_root) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3790 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
|
3791 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3792 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3793 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
|
3794 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3795 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3796 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
|
3797 free_parsed_command(&cmd); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3798 return ret; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3799 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3800 cd->genesis->header.enter_debugger = 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3801 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3802 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3803 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3804 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3805 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
|
3806 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
3807 char *param = cmd->raw; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3808 while (param && *param && isblank(*param)) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3809 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3810 ++param; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3811 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3812 m68k_context *m68k = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3813 genesis_context *gen = m68k->system; |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
3814 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3815 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
|
3816 parsed_command cmd = {0}; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3817 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
|
3818 if (!z80_root) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3819 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
|
3820 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3821 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3822 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
|
3823 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3824 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3825 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
|
3826 free_parsed_command(&cmd); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3827 return ret; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3828 } else { |
2184
408fb8a7e990
Implement argumentless variant of z80 debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2183
diff
changeset
|
3829 gen->enter_z80_debugger = 1; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3830 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3831 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3832 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3833 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3834 command_def common_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3835 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3836 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3837 "quit", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3838 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3839 .usage = "quit", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3840 .desc = "Quit BlastEm", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3841 .impl = cmd_quit, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3842 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3843 .max_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3844 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3845 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3846 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3847 "help", "?", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3848 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3849 .usage = "help", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3850 .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
|
3851 .impl = cmd_help, |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3852 .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
|
3853 .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
|
3854 .raw_args = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3855 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3856 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3857 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3858 "continue", "c", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3859 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3860 .usage = "continue", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3861 .desc = "Resume execution", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3862 .impl = cmd_continue, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3863 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3864 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3865 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3866 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3867 .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
|
3868 "print", "p", NULL |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3869 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3870 .usage = "print[/FORMAT] EXPRESSION...", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3871 .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
|
3872 .impl = cmd_print, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3873 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3874 .max_args = -1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3875 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3876 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3877 .names = (const char *[]){ |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3878 "printf", NULL |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3879 }, |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3880 .usage = "printf FORMAT EXPRESSION...", |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3881 .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
|
3882 .impl = cmd_printf, |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3883 .min_args = 1, |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
3884 .max_args = -1 |
2187
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3885 }, |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3886 { |
d0129f19ca52
Add a printf command to the debugger
Michael Pavone <pavone@retrodev.com>
parents:
2186
diff
changeset
|
3887 .names = (const char *[]){ |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3888 "softreset", "sr", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3889 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3890 .usage = "softreset", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3891 .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
|
3892 .impl = cmd_softreset, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3893 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3894 .max_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3895 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3896 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3897 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3898 "display", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3899 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3900 .usage = "display[/FORMAT] EXPRESSION...", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3901 .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
|
3902 .impl = cmd_display, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3903 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3904 .max_args = -1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3905 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3906 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3907 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3908 "deletedisplay", "dd", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3909 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3910 .usage = "deletedisplay DISPLAYNUM", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3911 .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
|
3912 .impl = cmd_delete_display, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3913 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3914 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3915 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3916 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3917 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3918 "commands", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3919 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3920 .usage = "command BREAKPOINT", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3921 .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
|
3922 .impl = cmd_command, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3923 .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
|
3924 .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
|
3925 .has_block = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3926 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3927 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3928 .names = (const char *[]){ |
2371
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3929 "function", NULL |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3930 }, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3931 .usage = "function NAME [ARGS...]", |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3932 .desc = "Creates a user-defined function named NAME with arguments ARGS", |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3933 .impl = cmd_function, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3934 .min_args = 1, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3935 .max_args = -1, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3936 .has_block = 1, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3937 .skip_eval = 1 |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3938 }, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3939 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3940 .names = (const char *[]){ |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3941 "return", NULL |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3942 }, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3943 .usage = "return VALUE", |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3944 .desc = "Return from a user defined function with the result VALUE", |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3945 .impl = cmd_return, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3946 .min_args = 1, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3947 .max_args = 1 |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3948 }, |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3949 { |
1fe5afe263f3
Initial stab at user-defined functions in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2367
diff
changeset
|
3950 .names = (const char *[]){ |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3951 "set", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3952 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3953 .usage = "set MEM|NAME VALUE", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3954 .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
|
3955 .impl = cmd_set, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3956 .min_args = 2, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3957 .max_args = 2, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
3958 .skip_eval = 1 |
2179
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3959 }, |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3960 { |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3961 .names = (const char *[]){ |
2358
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3962 "variable", NULL |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3963 }, |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3964 .usage = "variable NAME [VALUE]", |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3965 .desc = "Create a new variable called NAME and set it to VALUE or 0 if no value provided", |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3966 .impl = cmd_variable, |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3967 .min_args = 1, |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3968 .max_args = 2, |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3969 .skip_eval = 1 |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3970 }, |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3971 { |
4b2ac43c106e
Give debugger expression engine access to VDP and Sub CPU values. Add basic variable support
Michael Pavone <pavone@retrodev.com>
parents:
2357
diff
changeset
|
3972 .names = (const char *[]){ |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3973 "array", NULL |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3974 }, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3975 .usage = "array NAME [VALUE...]", |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3976 .desc = "Create a new array called NAME if it doesn't already exist. The array is initialized with the remaining parameters", |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3977 .impl = cmd_array, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3978 .min_args = 1, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3979 .max_args = -1, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3980 .skip_eval = 1 |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3981 }, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3982 { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3983 .names = (const char *[]){ |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3984 "append", NULL |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3985 }, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3986 .usage = "append NAME VALUE", |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3987 .desc = "Increase the size of array NAME by 1 and set the last element to VALUE", |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3988 .impl = cmd_append, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3989 .min_args = 2, |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
3990 .max_args = 2 |
2359
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3991 }, |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3992 { |
04d29635d238
Support for arrays in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2358
diff
changeset
|
3993 .names = (const char *[]){ |
2179
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3994 "frames", NULL |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3995 }, |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3996 .usage = "frames EXPRESSION", |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3997 .desc = "Resume execution for EXPRESSION video frames", |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3998 .impl = cmd_frames, |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
3999 .min_args = 1, |
9a8dd4ba2753
Implement frame advance debugger command
Michael Pavone <pavone@retrodev.com>
parents:
2178
diff
changeset
|
4000 .max_args = 1 |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4001 }, |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4002 { |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4003 .names = (const char *[]){ |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4004 "bindup", NULL |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4005 }, |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4006 .usage = "bindup NAME", |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4007 .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
|
4008 .impl = cmd_bindup, |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4009 .min_args = 1, |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
4010 .max_args = 1 |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4011 }, |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4012 { |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4013 .names = (const char *[]){ |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4014 "binddown", NULL |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4015 }, |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4016 .usage = "bindown NAME", |
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4017 .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
|
4018 .impl = cmd_binddown, |
2181
0c723b8b637c
Add bindup and binddown debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2180
diff
changeset
|
4019 .min_args = 1, |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
4020 .max_args = 1 |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4021 }, |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4022 { |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4023 .names = (const char *[]){ |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4024 "condition", NULL |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4025 }, |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4026 .usage = "condition BREAKPOINT [EXPRESSION]", |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4027 .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
|
4028 .impl = cmd_condition, |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
4029 .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
|
4030 .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
|
4031 .skip_eval = 1 |
2190
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4032 }, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4033 { |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4034 .names = (const char *[]){ |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4035 "if", NULL |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4036 }, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4037 .usage = "if CONDITION", |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4038 .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
|
4039 .impl = cmd_if, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4040 .min_args = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4041 .max_args = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4042 .has_block = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4043 .accepts_else = 1 |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4044 }, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4045 { |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4046 .names = (const char *[]){ |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4047 "while", NULL |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4048 }, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4049 .usage = "while CONDITION", |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4050 .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
|
4051 .impl = cmd_while, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4052 .min_args = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4053 .max_args = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4054 .has_block = 1, |
59e0dcc01b2c
Add 'if' and 'while' debugger commands
Michael Pavone <pavone@retrodev.com>
parents:
2189
diff
changeset
|
4055 .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
|
4056 }, |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4057 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4058 .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
|
4059 "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
|
4060 }, |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4061 .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
|
4062 .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
|
4063 .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
|
4064 .min_args = 0, |
2395
ebca8ab02701
Basic string support in debugger language
Michael Pavone <pavone@retrodev.com>
parents:
2394
diff
changeset
|
4065 .max_args = 1 |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4066 }, |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4067 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4068 .names = (const char *[]){ |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4069 "save", NULL |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4070 }, |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4071 .usage = "save[/SIZE] FILENAME ARRAY [COUNT]", |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4072 .desc = "Saves COUNT elements of size SIZE from the array or memory region specified by ARRAY to a file", |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4073 .impl = cmd_save, |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4074 .min_args = 2, |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4075 .max_args = 3, |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4076 .skip_eval = 1 |
2394
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4077 }, |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4078 { |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4079 .names = (const char *[]){ |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4080 "load", NULL |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4081 }, |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4082 .usage = "load[/SIZE] FILENAME ARRAY [COUNT]", |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4083 .desc = "Loads COUNT elements of size SIZE from a file to the array or memory region specified by ARRAY", |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4084 .impl = cmd_load, |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4085 .min_args = 2, |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4086 .max_args = 3, |
340299a76db7
Add debugger load command
Michael Pavone <pavone@retrodev.com>
parents:
2393
diff
changeset
|
4087 .skip_eval = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4088 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4089 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4090 #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
|
4091 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4092 command_def m68k_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4093 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4094 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4095 "breakpoint", "b", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4096 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4097 .usage = "breakpoint ADDRESSS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4098 .desc = "Set a breakpoint at ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4099 .impl = cmd_breakpoint_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4100 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4101 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4102 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4103 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4104 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4105 "advance", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4106 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4107 .usage = "advance ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4108 .desc = "Advance to ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4109 .impl = cmd_advance_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4110 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4111 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4112 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4113 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4114 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4115 "step", "s", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4116 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4117 .usage = "step", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4118 .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
|
4119 .impl = cmd_step_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4120 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4121 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4122 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4123 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4124 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4125 "over", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4126 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4127 .usage = "over", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4128 .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
|
4129 .impl = cmd_over_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4130 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4131 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4132 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4133 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4134 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4135 "next", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4136 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4137 .usage = "next", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4138 .desc = "Advance to the next instruction", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4139 .impl = cmd_next_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4140 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4141 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4142 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4143 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4144 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4145 "backtrace", "bt", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4146 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4147 .usage = "backtrace", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4148 .desc = "Print a backtrace", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4149 .impl = cmd_backtrace_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4150 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4151 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4152 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4153 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4154 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4155 "delete", "d", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4156 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4157 .usage = "delete BREAKPOINT", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4158 .desc = "Remove breakpoint identified by BREAKPOINT", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4159 .impl = cmd_delete_m68k, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4160 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4161 .max_args = 1 |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4162 }, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4163 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4164 .names = (const char *[]){ |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4165 "disassemble", "disasm", NULL |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4166 }, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4167 .usage = "disassemble [ADDRESS]", |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4168 .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
|
4169 .impl = cmd_disassemble_m68k, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4170 .min_args = 0, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4171 .max_args = 1 |
2112
3abb64bd0da6
Add support for printing strings in 68K debugger
Michael Pavone <pavone@retrodev.com>
parents:
2107
diff
changeset
|
4172 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4173 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4174 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4175 #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
|
4176 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4177 command_def genesis_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4178 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4179 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4180 "vdpsprites", "vs", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4181 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4182 .usage = "vdpsprites", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4183 .desc = "Print the VDP sprite table", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4184 .impl = cmd_vdp_sprites, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4185 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4186 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4187 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4188 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4189 .names = (const char *[]){ |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4190 "vdpregs", "vr", NULL |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4191 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4192 .usage = "vdpregs", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4193 .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
|
4194 .impl = cmd_vdp_regs, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4195 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4196 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4197 }, |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4198 { |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4199 .names = (const char *[]){ |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4200 "vdpregbreak", "vregbreak", "vrb", NULL |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4201 }, |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4202 .usage = "vdpregbreak [REGISTER [MASK]]", |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4203 .desc = "Enter debugger on VDP register write. If REGISTER is provided, breakpoint will only fire for writes to that register. If MASK is also provided, it will be applied to the register number before comparison with REGISTER", |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4204 .impl = cmd_vdp_reg_break, |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4205 .min_args = 0, |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4206 .max_args = 2 |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4207 }, |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4208 #ifndef NO_Z80 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4209 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4210 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4211 "z80", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4212 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4213 .usage = "z80 [COMMAND]", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4214 .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
|
4215 .impl = cmd_gen_z80, |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4216 .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
|
4217 .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
|
4218 .raw_args = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4219 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4220 #endif |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4221 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4222 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4223 "ymchannel", "yc", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4224 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4225 .usage = "ymchannel [CHANNEL]", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4226 .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
|
4227 .impl = cmd_ym_channel, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4228 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4229 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4230 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4231 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4232 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4233 "ymtimer", "yt", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4234 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4235 .usage = "ymtimer", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4236 .desc = "Print YM-2612 timer info", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4237 .impl = cmd_ym_timer, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4238 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4239 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4240 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4241 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4242 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4243 #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
|
4244 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4245 command_def scd_main_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4246 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4247 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4248 "subcpu", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4249 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4250 .usage = "subcpu [COMMAND]", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4251 .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
|
4252 .impl = cmd_sub, |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4253 .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
|
4254 .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
|
4255 .raw_args = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4256 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4257 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4258 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4259 #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
|
4260 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4261 command_def scd_sub_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4262 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4263 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4264 "maincpu", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4265 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4266 .usage = "maincpu [COMMAND]", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4267 .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
|
4268 .impl = cmd_main, |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4269 .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
|
4270 .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
|
4271 .raw_args = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4272 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4273 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4274 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4275 #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
|
4276 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4277 #ifndef NO_Z80 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4278 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4279 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
|
4280 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4281 uint32_t index; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4282 if (!debug_cast_int(cmd->args[0].value, &index)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4283 fprintf(stderr, "Argument to delete must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4284 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4285 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4286 bp_def **this_bp = find_breakpoint_idx(&root->breakpoints, index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4287 if (!*this_bp) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4288 fprintf(stderr, "Breakpoint %d does not exist\n", index); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4289 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4290 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4291 bp_def *tmp = *this_bp; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4292 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
|
4293 *this_bp = (*this_bp)->next; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4294 if (tmp->commands) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4295 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
|
4296 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4297 free_parsed_command(tmp->commands + i); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4298 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4299 free(tmp->commands); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4300 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4301 free(tmp); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4302 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4303 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4304 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4305 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
|
4306 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4307 uint32_t address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4308 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4309 fprintf(stderr, "Argument to breakpoint must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4310 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4311 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4312 zinsert_breakpoint(root->cpu_context, address, (uint8_t *)zdebugger); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4313 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
|
4314 new_bp->next = root->breakpoints; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4315 new_bp->address = address; |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4316 new_bp->mask = 0xFFFF; |
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
4317 new_bp->type = BP_TYPE_CPU; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4318 new_bp->index = root->bp_index++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4319 root->breakpoints = new_bp; |
2386
9f178feb3cb0
Prefix most hex-formatted values output by debugger with $ for consistency with number literal parsing
Michael Pavone <pavone@retrodev.com>
parents:
2380
diff
changeset
|
4320 printf("Z80 Breakpoint %d set at $%X\n", new_bp->index, address); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4321 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4322 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4323 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4324 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
|
4325 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4326 uint32_t address; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4327 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4328 fprintf(stderr, "Argument to advance must be an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4329 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4330 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4331 zinsert_breakpoint(root->cpu_context, address, (uint8_t *)zdebugger); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4332 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4333 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4334 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4335 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
|
4336 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4337 z80inst *inst = root->inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4338 z80_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4339 uint32_t after = root->after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4340 //TODO: handle conditional branches |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4341 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
|
4342 if (inst->addr_mode == Z80_IMMED) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4343 after = inst->immed; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4344 } 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
|
4345 #ifndef NEW_CORE |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4346 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
|
4347 } 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
|
4348 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
|
4349 } 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
|
4350 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
|
4351 #endif |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4352 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4353 } else if(inst->op == Z80_JR) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4354 after += inst->immed; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4355 } else if(inst->op == Z80_RET) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4356 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
|
4357 if (sp) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4358 after = *sp; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4359 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
|
4360 if (sp) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4361 after |= *sp << 8; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4362 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4363 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4364 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4365 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
|
4366 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4367 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4368 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4369 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
|
4370 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4371 fputs("not implemented yet\n", stderr); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4372 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4373 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4374 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4375 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
|
4376 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4377 z80inst *inst = root->inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4378 z80_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4379 uint32_t after = root->after; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4380 //TODO: handle conditional branches |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4381 if (inst->op == Z80_JP) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4382 if (inst->addr_mode == Z80_IMMED) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4383 after = inst->immed; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4384 } 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
|
4385 #ifndef NEW_CORE |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4386 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
|
4387 } 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
|
4388 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
|
4389 } 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
|
4390 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
|
4391 #endif |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4392 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4393 } else if(inst->op == Z80_JR) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4394 after += inst->immed; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4395 } else if(inst->op == Z80_RET) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4396 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
|
4397 if (sp) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4398 after = *sp; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4399 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
|
4400 if (sp) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4401 after |= *sp << 8; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4402 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4403 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4404 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4405 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
|
4406 return 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4407 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4408 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4409 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
|
4410 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4411 z80_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4412 uint32_t stack = context->sp; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4413 uint8_t non_adr_count = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4414 do { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4415 uint32_t bt_address = stack; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4416 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
|
4417 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4418 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4419 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
|
4420 if (bt_address != 0xFEEDFEED) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4421 stack += 4; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4422 non_adr_count = 0; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4423 z80inst inst; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4424 char buf[128]; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4425 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
|
4426 z80_decode(pc, &inst); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4427 z80_disasm(&inst, buf, bt_address); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4428 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
|
4429 } else { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4430 //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
|
4431 stack++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4432 non_adr_count++; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4433 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4434 //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
|
4435 } while (stack && non_adr_count < 6); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4436 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4437 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4438 |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4439 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
|
4440 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4441 z80_context *context = root->cpu_context; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4442 uint32_t address = root->address; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4443 if (cmd->num_args) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4444 if (!debug_cast_int(cmd->args[0].value, &address)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4445 fprintf(stderr, "Argument to disassemble must be an integer if provided\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4446 return 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4447 } |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4448 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4449 char disasm_buf[1024]; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4450 z80inst inst; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4451 do { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4452 label_def *def = find_label(root->disasm, address); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4453 if (def) { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4454 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
|
4455 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4456 printf("%s:\n", def->labels[i]); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4457 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4458 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4459 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
|
4460 uint8_t *after = z80_decode(pc, &inst); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4461 z80_disasm(&inst, disasm_buf, address); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4462 address += after - pc; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4463 printf("\t%s\n", disasm_buf); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4464 } while(!z80_is_terminal(&inst)); |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4465 return 1; |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4466 } |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4467 |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4468 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
|
4469 { |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
4470 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
|
4471 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
|
4472 { |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4473 ++param; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4474 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4475 genesis_context *gen = (genesis_context *)current_system; |
2186
935e684f2d58
Fix crash bug in expression parser
Michael Pavone <pavone@retrodev.com>
parents:
2185
diff
changeset
|
4476 |
2185
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4477 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
|
4478 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
|
4479 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
|
4480 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
|
4481 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
|
4482 return 1; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4483 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4484 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
|
4485 return 1; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4486 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4487 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
|
4488 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
|
4489 return ret; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4490 } else { |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4491 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
|
4492 return 0; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4493 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4494 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4495 |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4496 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
|
4497 { |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4498 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
|
4499 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
|
4500 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
|
4501 return 1; |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4502 } |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4503 |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4504 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
|
4505 { |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4506 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
|
4507 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
|
4508 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
|
4509 return 1; |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4510 } |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4511 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4512 command_def z80_commands[] = { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4513 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4514 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4515 "breakpoint", "b", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4516 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4517 .usage = "breakpoint ADDRESSS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4518 .desc = "Set a breakpoint at ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4519 .impl = cmd_breakpoint_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4520 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4521 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4522 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4523 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4524 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4525 "advance", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4526 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4527 .usage = "advance ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4528 .desc = "Advance to ADDRESS", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4529 .impl = cmd_advance_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4530 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4531 .max_args = 1 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4532 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4533 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4534 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4535 "step", "s", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4536 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4537 .usage = "step", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4538 .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
|
4539 .impl = cmd_step_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4540 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4541 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4542 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4543 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4544 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4545 "over", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4546 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4547 .usage = "over", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4548 .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
|
4549 .impl = cmd_over_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4550 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4551 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4552 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4553 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4554 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4555 "next", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4556 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4557 .usage = "next", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4558 .desc = "Advance to the next instruction", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4559 .impl = cmd_next_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4560 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4561 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4562 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4563 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4564 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4565 "backtrace", "bt", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4566 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4567 .usage = "backtrace", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4568 .desc = "Print a backtrace", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4569 .impl = cmd_backtrace_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4570 .min_args = 0, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4571 .max_args = 0 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4572 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4573 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4574 .names = (const char *[]){ |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4575 "delete", "d", NULL |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4576 }, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4577 .usage = "delete BREAKPOINT", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4578 .desc = "Remove breakpoint identified by BREAKPOINT", |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4579 .impl = cmd_delete_z80, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4580 .min_args = 1, |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4581 .max_args = 1 |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4582 }, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4583 { |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4584 .names = (const char *[]){ |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4585 "disassemble", "disasm", NULL |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4586 }, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4587 .usage = "disassemble [ADDRESS]", |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4588 .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
|
4589 .impl = cmd_disassemble_z80, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4590 .min_args = 0, |
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
4591 .max_args = 1 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4592 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4593 }; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4594 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4595 #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
|
4596 |
2185
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4597 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
|
4598 { |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4599 .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
|
4600 "m68k", NULL |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4601 }, |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4602 .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
|
4603 .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
|
4604 .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
|
4605 .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
|
4606 .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
|
4607 .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
|
4608 } |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4609 }; |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4610 |
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
4611 #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
|
4612 |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4613 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
|
4614 { |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4615 .names = (const char *[]){ |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4616 "vdpsprites", "vs", NULL |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4617 }, |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4618 .usage = "vdpsprites", |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4619 .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
|
4620 .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
|
4621 .min_args = 0, |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4622 .max_args = 0 |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4623 }, |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4624 { |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4625 .names = (const char *[]){ |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4626 "vdpsregs", "vr", NULL |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4627 }, |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4628 .usage = "vdpregs", |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4629 .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
|
4630 .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
|
4631 .min_args = 0, |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4632 .max_args = 0 |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4633 } |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4634 }; |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4635 |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4636 #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
|
4637 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4638 #endif |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4639 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4640 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
|
4641 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4642 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
|
4643 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4644 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
|
4645 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4646 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
|
4647 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4648 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4649 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4650 |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4651 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
|
4652 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4653 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
|
4654 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
|
4655 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
|
4656 { |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4657 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
|
4658 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4659 } |
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4660 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4661 static debug_val debug_frame_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4662 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4663 vdp_context *vdp = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4664 return debug_int(vdp->frame); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4665 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4666 |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4667 static uint32_t m68k_chunk_end(debug_root *root, uint32_t start_address) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4668 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4669 m68k_context *m68k = root->cpu_context; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4670 memmap_chunk const *chunk = find_map_chunk(start_address, &m68k->options->gen, 0, NULL); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4671 if (!chunk) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4672 return start_address; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4673 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4674 if (chunk->mask == m68k->options->gen.address_mask) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4675 return chunk->end; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4676 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4677 return (start_address & ~chunk->mask) + chunk->mask + 1; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4678 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4679 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4680 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
|
4681 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4682 debug_root *root = find_root(context); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4683 if (root && !root->commands) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4684 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
|
4685 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
|
4686 root->read_mem = read_m68k; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4687 root->write_mem = write_m68k; |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
4688 root->chunk_end = m68k_chunk_end; |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4689 root->disasm = create_68000_disasm(); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4690 m68k_names(root); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4691 debug_var *var; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4692 switch (current_system->type) |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4693 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4694 case SYSTEM_GENESIS: |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4695 case SYSTEM_SEGACD: |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4696 //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
|
4697 if (context->system == current_system) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4698 genesis_context *gen = context->system; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4699 root->other_roots = tern_insert_ptr(root->other_roots, "z80", find_z80_root(gen->z80)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4700 root->other_roots = tern_insert_ptr(root->other_roots, "vdp", find_vdp_root(gen->vdp)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4701 root->other_roots = tern_insert_ptr(root->other_roots, "ym", find_ym2612_root(gen->ym)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4702 root->other_roots = tern_insert_ptr(root->other_roots, "psg", find_psg_root(gen->psg)); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4703 add_commands(root, genesis_commands, NUM_GENESIS); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4704 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4705 var->get = debug_frame_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4706 var->ptr = gen->vdp; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4707 root->variables = tern_insert_ptr(root->variables, "frame", var); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4708 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
|
4709 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
|
4710 add_commands(root, scd_main_commands, NUM_SCD_MAIN); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4711 segacd_context *scd = gen->expansion; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4712 root->other_roots = tern_insert_ptr(root->other_roots, "sub", find_m68k_root(scd->m68k)); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4713 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4714 break; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4715 } 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
|
4716 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
|
4717 add_commands(root, scd_sub_commands, NUM_SCD_SUB); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4718 segacd_context *scd = context->system; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4719 root->other_roots = tern_insert_ptr(root->other_roots, "main", find_m68k_root(scd->genesis->m68k)); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4720 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4721 default: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4722 break; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4723 } |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
4724 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
|
4725 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4726 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
|
4727 } |
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
|
4728 |
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
|
4729 #ifndef NO_Z80 |
548
a3afee2271ce
Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents:
525
diff
changeset
|
4730 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4731 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
|
4732 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4733 z80_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4734 uint32_t address = *out; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4735 *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
|
4736 if (size == 'w') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4737 *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
|
4738 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4739 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4740 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4741 |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4742 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
|
4743 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4744 z80_context *context = root->cpu_context; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4745 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
|
4746 if (size == 'w') { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4747 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
|
4748 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4749 return 1; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4750 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4751 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4752 static debug_val z80_reg8_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4753 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4754 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4755 return debug_int(context->regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4756 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4757 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4758 static void z80_reg8_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4759 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4760 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4761 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4762 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4763 fprintf(stderr, "Z80 register %s can only be set to an integer\n", z80_regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4764 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4765 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4766 context->regs[var->val.v.u32] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4767 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4768 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4769 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4770 static debug_val z80_alt_reg8_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4771 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4772 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4773 return debug_int(context->alt_regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4774 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4775 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4776 static void z80_alt_reg8_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4777 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4778 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4779 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4780 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4781 fprintf(stderr, "Z80 register %s' can only be set to an integer\n", z80_regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4782 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4783 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4784 context->alt_regs[var->val.v.u32] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4785 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4786 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4787 static debug_val z80_flags_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4788 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4789 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4790 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4791 ret.type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4792 ret.v.u32 = context->flags[ZF_S] << 7; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4793 ret.v.u32 |= context->flags[ZF_Z] << 6; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4794 ret.v.u32 |= context->flags[ZF_H] << 4; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4795 ret.v.u32 |= context->flags[ZF_PV] << 2; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4796 ret.v.u32 |= context->flags[ZF_N] << 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4797 ret.v.u32 |= context->flags[ZF_C]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4798 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4799 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4800 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4801 static debug_val z80_alt_flags_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4802 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4803 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4804 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4805 ret.type = DBG_VAL_U32; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4806 ret.v.u32 = context->alt_flags[ZF_S] << 7; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4807 ret.v.u32 |= context->alt_flags[ZF_Z] << 6; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4808 ret.v.u32 |= context->alt_flags[ZF_H] << 4; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4809 ret.v.u32 |= context->alt_flags[ZF_PV] << 2; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4810 ret.v.u32 |= context->alt_flags[ZF_N] << 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4811 ret.v.u32 |= context->alt_flags[ZF_C]; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4812 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4813 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4814 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4815 static void z80_flags_set(debug_var *var, debug_val val) |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4816 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4817 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4818 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4819 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4820 fprintf(stderr, "Z80 register F can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4821 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4822 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4823 context->flags[ZF_S] = ival >> 7 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4824 context->flags[ZF_Z] = ival >> 6 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4825 context->flags[ZF_H] = ival >> 4 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4826 context->flags[ZF_PV] = ival >> 2 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4827 context->flags[ZF_N] = ival >> 1 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4828 context->flags[ZF_C] = ival & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4829 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4830 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4831 static void z80_alt_flags_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4832 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4833 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4834 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4835 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4836 fprintf(stderr, "Z80 register F' can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4837 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4838 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4839 context->alt_flags[ZF_S] = ival >> 7 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4840 context->alt_flags[ZF_Z] = ival >> 6 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4841 context->alt_flags[ZF_H] = ival >> 4 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4842 context->alt_flags[ZF_PV] = ival >> 2 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4843 context->alt_flags[ZF_N] = ival >> 1 & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4844 context->alt_flags[ZF_C] = ival & 1; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4845 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4846 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4847 static debug_val z80_regpair_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4848 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4849 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4850 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4851 if (var->val.v.u32 == Z80_AF) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4852 ret = z80_flags_get(var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4853 ret.v.u32 |= context->regs[Z80_A] << 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4854 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4855 ret = debug_int(context->regs[z80_high_reg(var->val.v.u32)] << 8 | context->regs[z80_low_reg(var->val.v.u32)]); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4856 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4857 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4858 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4859 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4860 static void z80_regpair_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4861 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4862 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4863 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4864 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4865 fprintf(stderr, "Z80 register %s can only be set to an integer\n", z80_regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4866 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4867 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4868 if (var->val.v.u32 == Z80_AF) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4869 context->regs[Z80_A] = ival >> 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4870 z80_flags_set(var, val); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4871 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4872 context->regs[z80_high_reg(var->val.v.u32)] = ival >> 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4873 context->regs[z80_low_reg(var->val.v.u32)] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4874 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4875 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4876 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4877 static debug_val z80_alt_regpair_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4878 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4879 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4880 debug_val ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4881 if (var->val.v.u32 == Z80_AF) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4882 ret = z80_alt_flags_get(var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4883 ret.v.u32 |= context->alt_regs[Z80_A] << 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4884 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4885 ret = debug_int(context->alt_regs[z80_high_reg(var->val.v.u32)] << 8 | context->alt_regs[z80_low_reg(var->val.v.u32)]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4886 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4887 return ret; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4888 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4889 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4890 static void z80_alt_regpair_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4891 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4892 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4893 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4894 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4895 fprintf(stderr, "Z80 register %s' can only be set to an integer\n", z80_regs[var->val.v.u32]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4896 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4897 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4898 if (var->val.v.u32 == Z80_AF) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4899 context->regs[Z80_A] = ival >> 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4900 z80_alt_flags_set(var, val); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4901 } else { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4902 context->alt_regs[z80_high_reg(var->val.v.u32)] = ival >> 8; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4903 context->alt_regs[z80_low_reg(var->val.v.u32)] = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4904 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4905 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4906 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4907 static debug_val z80_sp_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4908 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4909 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4910 return debug_int(context->sp); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4911 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4912 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4913 static void z80_sp_set(debug_var *var, debug_val val) |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4914 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4915 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4916 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4917 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4918 fprintf(stderr, "Z80 register sp can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4919 return; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4920 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4921 context->sp = ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4922 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4923 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4924 static debug_val z80_im_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4925 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4926 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4927 return debug_int(context->im); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4928 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4929 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4930 static void z80_im_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4931 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4932 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4933 uint32_t ival; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4934 if (!debug_cast_int(val, &ival)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4935 fprintf(stderr, "Z80 register im can only be set to an integer\n"); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4936 return; |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4937 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4938 context->im = ival & 3; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4939 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4940 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4941 static debug_val z80_iff1_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4942 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4943 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4944 return debug_int(context->iff1); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4945 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4946 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4947 static void z80_iff1_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4948 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4949 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4950 context->iff1 = debug_cast_bool(val); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4951 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4952 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4953 static debug_val z80_iff2_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4954 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4955 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4956 return debug_int(context->iff2); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4957 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4958 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4959 static void z80_iff2_set(debug_var *var, debug_val val) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4960 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4961 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4962 context->iff2 = debug_cast_bool(val); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4963 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4964 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4965 static debug_val z80_cycle_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4966 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4967 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4968 return debug_int(context->current_cycle); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4969 } |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4970 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4971 static debug_val z80_pc_get(debug_var *var) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4972 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4973 z80_context *context = var->ptr; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4974 return debug_int(context->pc); |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4975 } |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
4976 |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4977 static void z80_names(debug_root *root) |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4978 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4979 debug_var *var; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4980 for (int i = 0; i < Z80_UNUSED; i++) |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4981 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4982 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4983 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4984 if (i < Z80_BC) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4985 var->get = z80_reg8_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4986 var->set = z80_reg8_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4987 } else if (i == Z80_SP) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4988 var->get = z80_sp_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4989 var->set = z80_sp_set; |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4990 } else { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4991 var->get = z80_regpair_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4992 var->set = z80_regpair_set; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
4993 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4994 var->val.v.u32 = i; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4995 root->variables = tern_insert_ptr(root->variables, z80_regs[i], var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4996 size_t name_size = strlen(z80_regs[i]); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4997 char *name = malloc(name_size + 2); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4998 char *d = name; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
4999 for (const char *c = z80_regs[i]; *c; c++, d++) |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5000 { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5001 *d = toupper(*c); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5002 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5003 name[name_size] = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5004 root->variables = tern_insert_ptr(root->variables, name, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5005 |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5006 if (i < Z80_IXL || (i > Z80_R && i < Z80_IX && i != Z80_SP)) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5007 memcpy(name, z80_regs[i], name_size); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5008 name[name_size] = '\''; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5009 name[name_size + 1] = 0; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5010 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5011 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5012 if (i < Z80_BC) { |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5013 var->get = z80_alt_reg8_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5014 var->set = z80_alt_reg8_set; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5015 } else { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5016 var->get = z80_alt_regpair_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5017 var->set = z80_alt_regpair_set; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5018 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5019 var->val.v.u32 = i; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5020 root->variables = tern_insert_ptr(root->variables, name, var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5021 d = name; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5022 for (const char *c = z80_regs[i]; *c; c++, d++) |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5023 { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5024 *d = toupper(*c); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5025 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5026 root->variables = tern_insert_ptr(root->variables, name, var); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5027 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5028 free(name); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5029 } |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5030 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5031 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5032 var->get = z80_flags_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5033 var->set = z80_flags_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5034 root->variables = tern_insert_ptr(root->variables, "f", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5035 root->variables = tern_insert_ptr(root->variables, "F", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5036 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5037 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5038 var->get = z80_alt_flags_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5039 var->set = z80_alt_flags_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5040 root->variables = tern_insert_ptr(root->variables, "f'", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5041 root->variables = tern_insert_ptr(root->variables, "F'", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5042 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5043 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5044 var->get = z80_im_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5045 var->set = z80_im_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5046 root->variables = tern_insert_ptr(root->variables, "im", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5047 root->variables = tern_insert_ptr(root->variables, "IM", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5048 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5049 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5050 var->get = z80_iff1_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5051 var->set = z80_iff1_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5052 root->variables = tern_insert_ptr(root->variables, "iff1", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5053 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5054 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5055 var->get = z80_iff2_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5056 var->set = z80_iff2_set; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5057 root->variables = tern_insert_ptr(root->variables, "iff2", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5058 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5059 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5060 var->get = z80_cycle_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5061 root->variables = tern_insert_ptr(root->variables, "cycle", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5062 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5063 var->ptr = root->cpu_context; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5064 var->get = z80_pc_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5065 root->variables = tern_insert_ptr(root->variables, "pc", var); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5066 root->variables = tern_insert_ptr(root->variables, "PC", var); |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5067 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5068 |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5069 static uint32_t z80_chunk_end(debug_root *root, uint32_t start_address) |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5070 { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5071 z80_context *z80 = root->cpu_context; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5072 memmap_chunk const *chunk = find_map_chunk(start_address, &z80->options->gen, 0, NULL); |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5073 if (!chunk) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5074 return start_address; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5075 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5076 if (chunk->mask == z80->options->gen.address_mask) { |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5077 return chunk->end; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5078 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5079 return (start_address & ~chunk->mask) + chunk->mask + 1; |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5080 } |
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5081 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5082 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
|
5083 { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5084 debug_root *root = find_root(context); |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5085 if (root && !root->commands) { |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5086 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
|
5087 add_commands(root, z80_commands, NUM_Z80); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5088 z80_names(root); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5089 genesis_context *gen; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5090 sms_context *sms; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5091 debug_var *var; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5092 //TODO: populate names |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5093 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
|
5094 { |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5095 case SYSTEM_GENESIS: |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5096 case SYSTEM_SEGACD: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5097 gen = context->system; |
2185
3d2cc2af1da3
Add an m68k command for switching back to 68K debugger from Z80
Michael Pavone <pavone@retrodev.com>
parents:
2184
diff
changeset
|
5098 add_commands(root, gen_z80_commands, NUM_GEN_Z80); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5099 root->other_roots = tern_insert_ptr(root->other_roots, "m68k", find_m68k_root(gen->m68k)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5100 //root->resolve = resolve_z80; |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5101 break; |
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5102 case SYSTEM_SMS: |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5103 sms = context->system; |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5104 add_commands(root, sms_commands, NUM_SMS); |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5105 root->other_roots = tern_insert_ptr(root->other_roots, "vdp", find_vdp_root(sms->vdp)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5106 root->other_roots = tern_insert_ptr(root->other_roots, "psg", find_psg_root(sms->psg)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5107 var = calloc(1, sizeof(debug_var)); |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5108 var->get = debug_frame_get; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5109 var->ptr = sms->vdp; |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5110 root->variables = tern_insert_ptr(root->variables, "frame", var); |
2198
0dcb9e4dee7f
Give SMS debugger a bit more parity to the Genesis one
Michael Pavone <pavone@retrodev.com>
parents:
2193
diff
changeset
|
5111 break; |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5112 //default: |
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5113 //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
|
5114 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5115 root->read_mem = read_z80; |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5116 root->write_mem = write_z80; |
2216
4e27c36f947c
Add disassemble command to debugger
Michael Pavone <pavone@retrodev.com>
parents:
2214
diff
changeset
|
5117 root->disasm = create_z80_disasm(); |
2393
5f4917b9ecfa
Add debugger save command
Michael Pavone <pavone@retrodev.com>
parents:
2386
diff
changeset
|
5118 root->chunk_end = z80_chunk_end; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5119 } |
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5120 return root; |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5121 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5122 |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5123 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
|
5124 { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5125 static char last_cmd[1024]; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5126 char input_buf[1024]; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5127 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
|
5128 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
|
5129 init_terminal(); |
2180
b87658ba3b94
Fix bug in Z80 debugger for SMS mode post-refactor
Michael Pavone <pavone@retrodev.com>
parents:
2179
diff
changeset
|
5130 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
|
5131 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
|
5132 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
|
5133 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
5134 root->address = address; |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5135 //Check if this is a user set breakpoint, or just a temporary one |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
5136 bp_def ** this_bp = find_breakpoint(&root->breakpoints, address, BP_TYPE_CPU); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5137 if (*this_bp) { |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5138 if ((*this_bp)->condition) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5139 debug_val condres; |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5140 if (eval_expr(root, (*this_bp)->condition, &condres)) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5141 if (!condres.v.u32) { |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5142 return context; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5143 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5144 } else { |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5145 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
|
5146 free_expr((*this_bp)->condition); |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5147 (*this_bp)->condition = NULL; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5148 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5149 } |
2208
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5150 int debugging = 1; |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5151 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
|
5152 { |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5153 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
|
5154 } |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5155 if (debugging) { |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5156 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
|
5157 } else { |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5158 return context; |
3809a0bd680e
Fix a couple of Z80 debugger issues
Michael Pavone <pavone@retrodev.com>
parents:
2198
diff
changeset
|
5159 } |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5160 } else { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5161 zremove_breakpoint(context, address); |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5162 } |
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
|
5163 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
|
5164 if (!pc) { |
6b5c92b6205c
Enabled Z80 debugger in PBC mode
Michael Pavone <pavone@retrodev.com>
parents:
1111
diff
changeset
|
5165 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
|
5166 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
5167 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
|
5168 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
|
5169 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
|
5170 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
|
5171 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
|
5172 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
|
5173 make_format_str(format_str, cur->format); |
2183
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5174 for (int i = 0; i < cur->num_args; i++) |
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5175 { |
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5176 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
|
5177 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
|
5178 } |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5179 } |
2188
e17d99c96c89
Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command
Michael Pavone <pavone@retrodev.com>
parents:
2187
diff
changeset
|
5180 |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5181 z80_disasm(&inst, input_buf, address); |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5182 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
|
5183 debugger_repl(root); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5184 return context; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5185 } |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5186 |
548
a3afee2271ce
Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents:
525
diff
changeset
|
5187 #endif |
a3afee2271ce
Initial work on the x86-32 target
Michael Pavone <pavone@retrodev.com>
parents:
525
diff
changeset
|
5188 |
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
|
5189 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
|
5190 { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5191 static char last_cmd[1024]; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5192 char input_buf[1024]; |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5193 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
|
5194 |
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
|
5195 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
|
5196 |
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
|
5197 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
|
5198 if (context->system == current_system) { |
ff32a90260c9
Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents:
2054
diff
changeset
|
5199 genesis_context *gen = context->system; |
ff32a90260c9
Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents:
2054
diff
changeset
|
5200 vdp_force_update_framebuffer(gen->vdp); |
ff32a90260c9
Initial support for using debugger on sub CPU
Michael Pavone <pavone@retrodev.com>
parents:
2054
diff
changeset
|
5201 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5202 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
|
5203 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
|
5204 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
|
5205 } |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5206 //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
|
5207 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
|
5208 if (address == root->branch_t) { |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
5209 bp_def ** f_bp = find_breakpoint(&root->breakpoints, root->branch_f, BP_TYPE_CPU); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5210 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
|
5211 remove_breakpoint(context, root->branch_f); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5212 } |
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
|
5213 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
|
5214 } else if(address == root->branch_f) { |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
5215 bp_def ** t_bp = find_breakpoint(&root->breakpoints, root->branch_t, BP_TYPE_CPU); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5216 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
|
5217 remove_breakpoint(context, root->branch_t); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5218 } |
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
|
5219 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
|
5220 } |
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
|
5221 |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5222 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
|
5223 int debugging = 1; |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5224 //Check if this is a user set breakpoint, or just a temporary one |
2361
3350b3c8faa8
Initial implementation of VDP register write breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2360
diff
changeset
|
5225 bp_def ** this_bp = find_breakpoint(&root->breakpoints, address, BP_TYPE_CPU); |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5226 if (*this_bp) { |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5227 if ((*this_bp)->condition) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5228 debug_val condres; |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5229 if (eval_expr(root, (*this_bp)->condition, &condres)) { |
2362
b6c5a0fa3dfc
Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support
Michael Pavone <pavone@retrodev.com>
parents:
2361
diff
changeset
|
5230 if (!condres.v.u32) { |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5231 return; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5232 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5233 } else { |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5234 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
|
5235 free_expr((*this_bp)->condition); |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5236 (*this_bp)->condition = NULL; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5237 } |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5238 } |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5239 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
|
5240 { |
2178
f6d5bde4d07f
Finish debugger refactor started with expression parser changes
Michael Pavone <pavone@retrodev.com>
parents:
2177
diff
changeset
|
5241 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
|
5242 } |
5a3ac6093ea2
Add support for executing a list of debugger commands when a breakpoint is hit
Michael Pavone <pavone@retrodev.com>
parents:
829
diff
changeset
|
5243 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
|
5244 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
|
5245 } 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
|
5246 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
|
5247 } |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5248 } else { |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5249 remove_breakpoint(context, address); |
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5250 } |
2182
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5251 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
|
5252 root->after = after; |
2d7f8195be3b
Add support for conditional breakpoints
Michael Pavone <pavone@retrodev.com>
parents:
2181
diff
changeset
|
5253 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
|
5254 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
|
5255 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
|
5256 make_format_str(format_str, cur->format); |
2183
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5257 for (int i = 0; i < cur->num_args; i++) |
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5258 { |
eb2e0e61b1b4
Fix stale values in display
Michael Pavone <pavone@retrodev.com>
parents:
2182
diff
changeset
|
5259 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
|
5260 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
|
5261 } |
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
|
5262 } |
2214
7591c67b8d1e
Support for loading symbols in debugger for use during name resolution and disassembly
Michael Pavone <pavone@retrodev.com>
parents:
2208
diff
changeset
|
5263 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
|
5264 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
|
5265 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
|
5266 return; |
524
fb39534b6604
Move debugging code outside of main source file
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5267 } |