repos/blastem: debug.c annotate

annotate debug.c @ 2365:8c060849a503

Basic function call support in debug language

author	Michael Pavone <pavone@retrodev.com>
date	Wed, 08 Nov 2023 23:47:26 -0800
parents	c822bb628fc3
children	1e36d8a2633c

rev	line source
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1 #include "debug.h"
1103 22e87b739ad6 WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well. Michael Pavone <pavone@retrodev.com> parents: 985 diff changeset	2 #include "genesis.h"
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	3 #include "68kinst.h"
2104 ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4 #include "segacd.h"
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	5 #include "blastem.h"
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	6 #include "bindings.h"
2177 44596610b2a0 Fix Windows build Michael Pavone <pavone@retrodev.com> parents: 2175 diff changeset	7 #include <ctype.h>
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	8 #include <stdlib.h>
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 #include <string.h>
745 daa31ee7d8cd Get windows build compiling again post-merge Michael Pavone <pavone@retrodev.com> parents: 723 diff changeset	10 #ifndef _WIN32
723 7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger Michael Pavone <pavone@retrodev.com> parents: 707 diff changeset	11 #include <sys/select.h>
745 daa31ee7d8cd Get windows build compiling again post-merge Michael Pavone <pavone@retrodev.com> parents: 723 diff changeset	12 #endif
723 7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger Michael Pavone <pavone@retrodev.com> parents: 707 diff changeset	13 #include "render.h"
792 724bbec47f86 Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows). Michael Pavone <pavone@retrodev.com> parents: 747 diff changeset	14 #include "util.h"
794 792be135d3af Spawn a terminal for the debugger when needed if we are not already attached to one Michael Pavone <pavone@retrodev.com> parents: 792 diff changeset	15 #include "terminal.h"
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	16 #include "z80inst.h"
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	17 #ifndef NO_Z80
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	18 #include "sms.h"
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	19 #endif
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	20
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	21 #ifdef NEW_CORE
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	22 #define Z80_OPTS opts
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	23 #else
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	24 #define Z80_OPTS options
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	25 #endif
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	26
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	27 static debug_func *funcs;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	28 static uint32_t num_funcs, func_storage;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	29
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	30 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	31 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	32 if (num_funcs == func_storage) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	33 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	34 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	35 }
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	36 return funcs + num_funcs++;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	37 }
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 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	40 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	41 debug_func *f = alloc_func();
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	42 f->impl.native = impl;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	43 f->max_args = max_args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	44 f->min_args = min_args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	45 f->is_native = 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	46 return (debug_val) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	47 .v = {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	48 .u32 = f - funcs
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	49 },
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	50 .type = DBG_VAL_FUNC
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	51 };
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	52 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	53
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	54 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	55 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	56 return var->val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	57 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	58
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	59 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	60 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	61 var->val = val;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	62 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	63
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	64 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	65 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	66 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	67 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	68 var->set = user_var_set;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	69 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	70 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	71 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	72
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	73 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	74 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	75 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	76 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	77 var->set = NULL;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	78 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	79 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	80 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	81
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	82 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	83 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	84 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	85 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	86 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	87 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	88 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	89 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	90 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	91 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	92
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	93 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	94 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	95 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	96 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	97 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	98 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	99 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	100 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	101 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	102 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	103 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	104 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	110 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	111 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	114 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	116 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	117 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	120 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	122 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	123 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	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 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	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 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	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_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	132 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	133 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	134 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	135 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	136 array->storage = size ? size : 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	137 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	138 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	139 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	140 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	141 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	146 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	147 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	149 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	151 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	152 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	153 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	154 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	155 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	156 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	157 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	158 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	159 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	160 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	161 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	162 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	164 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	165 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	166 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	167 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	168 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	169 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	170 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	171 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	172 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	173 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	174 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	175 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	176
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	177 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	178 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	179 switch(val.type)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	180 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	181 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	182 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	183 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	184 default: return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	185 }
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	186 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	187
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	188 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	189 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	190 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	191 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	192 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	193 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	194 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	195
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	196 static debug_val debug_float(float f)
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	197 {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	198 return (debug_val) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	199 .type = DBG_VAL_F32,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	200 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	201 .f32 = f
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	202 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	203 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	204 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	205
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	206 debug_val debug_sin(debug_val *args, int num_args)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	207 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	208 float f;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	209 if (!debug_cast_float(args[0], &f)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	210 return debug_float(0.0f);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	211 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	212 return debug_float(sinf(f));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	213 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	214
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	215 static debug_root *roots;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	216 static uint32_t num_roots, root_storage;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	217
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	218 debug_root find_root(void cpu)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	219 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	220 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	221 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	222 if (roots[i].cpu_context == cpu) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	223 return roots + i;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	224 }
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 (num_roots == root_storage) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	227 root_storage = root_storage ? root_storage * 2 : 5;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	228 roots = realloc(roots, root_storage * sizeof(debug_root));
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 debug_root *root = roots + num_roots++;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	231 memset(root, 0, sizeof(debug_root));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	232 root->cpu_context = cpu;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	233 new_readonly_variable(root, "sin", new_native_func(debug_sin, 1, 1));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	234 return root;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	235 }
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 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	238 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	239 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	240 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	241 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	242 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	243 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	244 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	245 return cur;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	246 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	247
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	248 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	249 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	250 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	251 if ((*cur)->index == index) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	252 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	253 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	254 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	255 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	256 return cur;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	257 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	258
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	259 static const char *token_type_names[] = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	260 "TOKEN_NONE",
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	261 "TOKEN_INT",
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	262 "TOKEN_DECIMAL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	263 "TOKEN_NAME",
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	264 "TOKEN_ARRAY",
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	265 "TOKEN_FUNCALL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	266 "TOKEN_OPER",
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	267 "TOKEN_SIZE",
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	268 "TOKEN_LBRACKET",
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	269 "TOKEN_RBRACKET",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	270 "TOKEN_LPAREN",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	271 "TOKEN_RPAREN"
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	272 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	273
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	274 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	275 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	276 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	277 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	278 ++start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	279 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	280 if (!start \|\| start == '\n' \|\| *start == '\r') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	281 return (token){
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	282 .type = TOKEN_NONE
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	283 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	284 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	285 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	286 if (start == '$' \|\| (start == '0' && start[1] == 'x')) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	287 return (token) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	288 .type = TOKEN_INT,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	289 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	290 .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	291 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	292 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	293 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	294 if (isdigit(*start)) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	295 uint32_t ipart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	296 if (**end == '.') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	297 start = *end + 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	298 uint32_t fpart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	299 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	300 if (fpart) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	301 float divisor = powf(10.0f, *end - start);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	302 fval = ipart + fpart / divisor;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	303 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	304 fval = ipart;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	305 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	306 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	307 .type = TOKEN_DECIMAL,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	308 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	309 .f = fval
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	310 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	311 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	312 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	313 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	314 .type = TOKEN_INT,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	315 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	316 .num = ipart
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	317 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	318 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	319 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	320 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	321 switch (*start)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	322 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	323 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	324 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	325 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	326 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	327 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	328 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	329 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	330 case '~':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	331 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	332 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	333 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	334 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	335 if ((start == '!' \|\| start == '>' \|\| *start == '<') && start[1] == '=') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	336 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	337 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	338 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	339 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	340 .op = {*start, start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	341 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	342 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	343 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	344 *end = start + 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	345 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	346 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	347 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	348 .op = {*start, 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	349 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	350 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	351 case '.':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	352 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	353 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	354 .type = TOKEN_SIZE,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	355 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	356 .op = {start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	357 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	358 };
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	359 case '[':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	360 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	361 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	362 .type = TOKEN_LBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	363 };
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	364 case ']':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	365 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	366 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	367 .type = TOKEN_RBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	368 };
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	369 case '(':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	370 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	371 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	372 .type = TOKEN_LPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	373 };
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	374 case ')':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	375 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	376 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	377 .type = TOKEN_RPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	378 };
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	379 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	380 *end = start + 1;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	381 token_type type = TOKEN_NAME;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	382 while (end && !isspace(end))
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	383 {
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	384 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	385 switch (**end)
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	386 {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	387 case '[':
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	388 type = TOKEN_ARRAY;
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	389 done = 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	390 break;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	391 case '(':
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	392 type = TOKEN_FUNCALL;
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	393 case '+':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	394 case '-':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	395 case '*':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	396 case '/':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	397 case '&':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	398 case '\|':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	399 case '^':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	400 case '~':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	401 case '=':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	402 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	403 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	404 case '<':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	405 case '.':
2357 344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	406 case ']':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	407 case ')':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	408 done = 1;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	409 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	410 }
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	411 if (done) {
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	412 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	413 }
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	414
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	415 ++*end;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	416 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	417 char name = malloc(end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	418 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	419 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	420 return (token) {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	421 .type = type,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	422 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	423 .str = name
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	424 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	425 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	426 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	427
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	428 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	429 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	430 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	431 free_expr(e->left);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	432 if (e->type == EXPR_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	433 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	434 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	435 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	436 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	437 free(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	438 } else {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	439 free_expr(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	440 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	441 if (e->op.type == TOKEN_NAME) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	442 free(e->op.v.str);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	443 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	444 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	445
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	446 static void free_expr(expr *e)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	447 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	448 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	449 return;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	450 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	451 free_expr_int(e);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	452 free(e);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	453 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	454
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	455 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	456 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	457
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	458 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	459 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	460 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	461 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	462 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	463 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	464 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	465 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	466 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	467 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	468 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	469 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	470 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	471 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	472 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	473 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	474 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	475 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	476 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	477 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	478 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	479 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	480 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	481 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	482 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	483 //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	484 //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	485 //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	486 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	487 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	488 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	489 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	490
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	491 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	492 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	493 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	494 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	495 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	496 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	497 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	498 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	499 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	500 return NULL;
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 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	503 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	504 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	505 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	506 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	507 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	508 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	509 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	510 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	511 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	512 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	513 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	514 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	515 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	516 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	517 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	518 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	519 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	520 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	521 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	522 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	523 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	524 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	525 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	526 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	527
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	528 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	529 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	530 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	531 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	532 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	533 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	534 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	535 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	536 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	537 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	538 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	539 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	540 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	541 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	542 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	543 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	544 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	545 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	546 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	547 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	548 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	549 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	550 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	551 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	552 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	553 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	554 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	555 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	556 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	557 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	558 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	559 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	560 return ret;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	561 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	562 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	563 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	564 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	565 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	566 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	567 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	568 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	569 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	570 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	571 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	572 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	573 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	574 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	575 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	576 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	577 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	578 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	579 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	580 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	581 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	582 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	583 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	584 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	585 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	586 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	587 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	588 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	589 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	590 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	591 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	592 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	593 return ret;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	594 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	595 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME) {
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	596 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	597 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	598 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	599 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	600 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	601 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	602 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	603 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	604 handle_namespace(ret);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	605 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	606 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	607 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	608 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	609 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	610 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	611 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	612 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	613 handle_namespace(ret->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	614 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	615 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	616 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	617
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	618 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	619 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	620 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	621 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	622 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	623 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	624 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	625 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	626 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	627 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	628 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	629 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	630 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	631 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	632 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	633 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	634 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	635 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	636 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	637 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	638 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	639 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	640 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	641 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	642 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	643 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	644 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	645 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	646 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	647 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	648 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	649 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	650 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	651 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	652 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	653 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	654 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	655
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	656 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	657 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	658 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	659 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	660 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	661 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	662 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	663 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	664 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	665 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	666 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	667 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	668 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	669 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	670 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	671 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	672 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	673 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	674 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	675 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	676 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	677 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	678 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	679 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	680 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	681 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	682 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	683
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	684 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	685 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	686 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	687 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	688 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	689 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	690 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	691 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	692 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	693 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	694 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	695 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	696 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	697 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	698 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	699 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	700 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	701 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	702 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	703 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	704 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	705 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	706 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	707 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	708 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	709 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	710 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	711 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	712 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	713 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	714 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	715 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	716 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	717 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	718 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	719
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	720 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	721 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	722 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	723 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	724 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	725 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	726 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	727 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	728 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	729 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	730 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	731 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	732 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	733 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	734 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	735 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	736 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	737 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	738 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	739 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	740 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	741 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	742 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	743 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	744 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	745 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	746 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	747 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	748 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	749 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	750 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	751 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	752 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	753 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	754 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	755 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	756 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	757 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	758 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	759 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	760 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	761 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	762 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	763 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	764 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	765 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	766 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	767 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	768 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	769 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	770 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	771 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	772 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	773 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	774 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	775 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	776 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	777 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	778 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	779 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	780 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	781 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	782 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	783 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	784 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	785 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	786 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	787 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME) {
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	788 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	789 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	790 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	791 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	792 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	793 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	794 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	795 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	796 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	797 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	798 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	799 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	800 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	801 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	802 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	803 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	804 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	805 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	806 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	807 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	808 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	809 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	810 return maybe_muldiv(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	811 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	812 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	813 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	814 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	815 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	816 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	817 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	818 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	819 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	820 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	821 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	822 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	823 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	824 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	825 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	826 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	827 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	828 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	829 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	830 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	831 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	832 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	833 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	834 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	835 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	836 } else {
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	837 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	838 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	839 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	840 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	841 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	842 return ret;
2169 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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	845
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	846 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	847 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	848 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	849 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	850 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	851 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	852 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	853 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	854 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	855 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	856 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	857 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	858 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	859 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	860 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	861 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	862 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	863 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	864 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	865 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	866 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	867 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	868 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	869 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	870 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	871 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	872 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	873 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	874 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	875 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	876 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	877 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	878 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	879 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	880 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	881
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	882 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	883 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	884 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	885 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	886 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	887 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	888 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	889 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	890 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	891 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	892 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	893 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	894 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	895 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	896 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	897 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	898 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	899 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	900 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	901 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	902 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	903 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	904 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	905 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	906 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	907 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	908 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	909 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	910 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	911 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	912 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	913 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	914 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	915 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	916 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	917 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	918 ret->type = EXPR_FUNCALL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	919 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	920 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	921 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	922 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	923 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	924 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	925 //consume LPAREN
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	926 parse_token(after_first, end);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	927 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	928 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	929 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	930 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	931 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	932 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	933 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	934 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	935 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	936 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	937 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	938 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	939 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	940 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	941 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	942 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	943 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	944 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	945 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	946 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	947 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	948 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	949 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	950 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	951 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	952 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	953 if (first.type != TOKEN_INT && first.type != TOKEN_DECIMAL && first.type != TOKEN_NAME) {
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	954 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	955 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	956 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	957 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	958 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	959 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	960 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	961 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	962 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	963 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	964 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	965 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	966 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	967 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	968 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	969 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	970 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	971 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	972 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	973 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	974 bin->right = parse_scalar(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	975 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	976 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	977 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	978 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	979 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	980 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	981 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	982 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	983 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	984 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	985 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	986 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	987 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	988 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	989 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	990 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	991 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	992 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	993 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	994 bin->right = parse_expression(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	995 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	996 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	997 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	998 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	999 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1000 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1001 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1002 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	1003 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1004 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1005 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1006 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1007 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1008 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1009 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1010 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1011 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1012 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1013 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	1014 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1015 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1016 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1017 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1018 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1019 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1020 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1021 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1022 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	1023 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1024 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1025 return ret;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1026 }
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
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	1029 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	1030 {
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	1031 debug_val right;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1032 debug_val *args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1033 debug_func *func;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1034 int num_args;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1035 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1036 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1037 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	1038 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	1039 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	1040 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	1041 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	1042 }
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	1043 *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	1044 return 1;
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1045 } else if (e->op.type == TOKEN_INT) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1046 *out = debug_int(e->op.v.num);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1047 return 1;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1048 } else {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1049 *out = debug_float(e->op.v.f);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1050 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1051 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1052 case EXPR_UNARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1053 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	1054 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1055 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1056 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1057 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1058 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	1059 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	1060 out->v.u32 = !out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1061 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1062 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	1063 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	1064 out->v.u32 = ~out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1065 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1066 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	1067 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	1068 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	1069 } 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	1070 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	1071 } 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	1072 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	1073 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	1074 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1075 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1076 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1077 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1078 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1079 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1080 case EXPR_BINARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1081 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	1082 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1083 }
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	1084 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	1085 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	1086 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	1087 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	1088 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	1089 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	1090 } 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	1091 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	1092 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	1093 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1094 } 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	1095 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	1096 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	1097 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	1098 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	1099 } 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	1100 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	1101 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	1102 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1104 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1105 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	1106 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	1107 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1108 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	1109 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	1110 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	1111 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	1112 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	1113 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	1114 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	1115 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	1116 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	1117 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	1118 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	1119 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	1120 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	1121 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	1122 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	1123 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	1124 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	1125 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	1126 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	1127 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	1128 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	1129 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	1130 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	1131 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	1132 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	1133 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	1134 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	1135 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	1136 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	1137 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	1138 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	1139 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	1140 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	1141 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	1142 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	1143 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1144 } 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	1145 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	1146 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1147 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	1148 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	1149 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	1150 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	1151 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	1152 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	1153 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	1154 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	1155 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	1156 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	1157 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	1158 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	1159 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	1160 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	1161 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	1162 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	1163 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	1164 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	1165 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	1166 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	1167 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	1168 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	1169 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	1170 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	1171 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	1172 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	1173 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	1174 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	1175 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	1176 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	1177 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1178 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1179 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1180 case EXPR_SIZE:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1181 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	1182 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1183 }
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	1184 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	1185 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1186 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1187 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	1188 out->v.u32 &= 0xFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1189 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1190 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	1191 out->v.u32 &= 0xFFFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1192 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1193 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1194 return 1;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1195 case EXPR_MEM:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1196 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	1197 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1198 }
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	1199 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	1200 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	1201 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	1202 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	1203 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1204 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	1205 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	1206 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	1207 return 0;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1208 }
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	1209 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	1210 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	1211 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1212 *out = array->get(array, out->v.u32);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1213 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1214 }
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	1215 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	1216 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	1217 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	1218 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	1219 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	1220 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	1221 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1222 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	1223 case EXPR_FUNCALL:
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1224 if (!eval_expr(root, e->left, out)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1225 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1226 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1227 if (out->type != DBG_VAL_FUNC) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1228 fprintf(stderr, "Funcall expression requires function");
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1229 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1230 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1231 func = funcs + out->v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1232 num_args = e->op.v.num;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1233 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	1234 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	1235 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1236 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1237 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	1238 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	1239 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1240 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1241 args = calloc(num_args, sizeof(debug_val));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1242 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	1243 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1244 if (!eval_expr(root, e->right + i, args + i)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1245 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1246 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1247 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1248 if (func->is_native) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1249 *out = func->impl.native(args, num_args);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1250 } else {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1251 //TODO: Implement me
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1252 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1253 return 1;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1254 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1255 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1256 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1257 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1258
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1259 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1260 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1261 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1262 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1263 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1264 return buf+1;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1265 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1266 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1267 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1268 return NULL;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1269 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1270
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1271 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1272 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1273 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1274 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1275 *buf = 0;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1276 return;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1277 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1278 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1279 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1280
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	1281 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	1282 {
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	1283 //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	1284 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	1285 }
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	1286
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1287 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	1288 {
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	1289 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	1290 }
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	1291
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1292 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	1293 {
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	1294 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	1295 }
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	1296
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1297 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	1298 {
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1299 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	1300 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1301 out = m68k_read_byte(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1302 } else if (size == 'l') {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1303 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1304 fprintf(stderr, "Longword access to odd addresses (%X) is not allowed\n", *out);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1305 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1306 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1307 out = m68k_read_long(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1308 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1309 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1310 fprintf(stderr, "Wword access to odd addresses (%X) is not allowed\n", *out);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1311 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1312 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1313 out = m68k_read_word(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1314 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1315 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1316 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1317
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1318 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	1319 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1320 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1321 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1322 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	1323 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1324 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1325 fprintf(stderr, "Longword access to odd addresses (%X) is not allowed\n", address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1326 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1327 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1328 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	1329 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	1330 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1331 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1332 fprintf(stderr, "Wword access to odd addresses (%X) is not allowed\n", address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1333 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1334 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1335 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	1336 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1337 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1338 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1339
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	1340 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	1341 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1343 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	1344 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1345
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	1346 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	1347 {
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	1348 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	1349 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	1350 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	1351 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	1352 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	1353 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 context->dregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1355 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1356
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	1357 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	1358 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1360 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	1361 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1364 {
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	1365 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	1366 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	1367 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	1368 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	1369 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	1370 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 context->aregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1372 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1373
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	1374 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	1375 {
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	1376 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	1377 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	1378 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	1379 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	1380 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1382 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1384 return ret;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1385 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1386
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	1387 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	1388 {
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	1389 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	1390 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	1391 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	1392 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	1393 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	1394 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1396 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	1397 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	1398 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1399 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1400
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	1401 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	1402 {
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	1403 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	1404 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	1405 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1406
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1407 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	1408 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1409 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	1410 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	1411 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1412
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	1413 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	1414 {
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	1415 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	1416 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	1417 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	1418 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	1419 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	1420 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1421 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	1422 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1423
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	1424 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	1425 {
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	1426 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	1427 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	1428 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1429
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	1430 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	1431 {
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	1432 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	1433 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	1434 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	1435 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	1436 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1437 }
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	1438 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1441 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	1442 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1444 return debug_int(root->address);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1445 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1446
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	1447 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	1448 {
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	1449 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	1450 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	1451 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1452 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	1453 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	1454 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	1455 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	1456 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	1457 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	1458 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	1459 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	1460 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	1461
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1462 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	1463 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	1464 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	1465 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	1466 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	1467 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	1468 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	1469 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	1470 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	1471 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	1472 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	1473 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	1474 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1475 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1476
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1477 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	1478 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	1479 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	1480 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	1481 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	1482 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	1483
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1484 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	1485 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	1486 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	1487 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	1488 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	1489
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1490 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	1491 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	1492 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	1493 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	1494 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	1495 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	1496
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1497 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	1498 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	1499 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	1500 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	1501 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	1502 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	1503
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1504 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	1505 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	1506 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	1507 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	1508 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1509
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	1510 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	1511 {
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	1512 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	1513 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	1514 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1515
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1516 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	1517 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1518 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	1519 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	1520 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1521
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	1522 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	1523 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1524 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	1525 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	1526 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1527
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1528 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	1529 {
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	1530 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	1531 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	1532 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	1533 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	1534 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	1535 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1536 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	1537 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1538
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1539 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	1540 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1541 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	1542 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	1543 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1544
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	1545 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	1546 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1547 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	1548 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	1549 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	1550 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	1551 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	1552 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1553 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	1554 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1555
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1556 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	1557 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1558 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	1559 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	1560 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1561
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1562 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	1563 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1564 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	1565 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	1566 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1567
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1568 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	1569 {
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	1570 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	1571 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	1572 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	1573 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	1574 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1575 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	1576 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	1577 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1578
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1579 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	1580 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1581 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	1582 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	1583 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1586 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1588 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	1589 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	1590 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	1591 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1593 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	1594 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1599 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	1600 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1601
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	1602 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	1603 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1605 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	1606 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	1607 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	1608 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1610 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	1611 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1614 {
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	1615 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	1616 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	1617 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1619 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	1620 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1622 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	1623 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	1624 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	1625 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1626 }
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	1627 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	1628 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1629
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	1630 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	1631 {
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	1632 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	1633 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	1634 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	1635 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	1636 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	1637
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1639 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	1640 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	1641 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	1642
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	1643 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	1644 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	1645 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	1646 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	1647 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	1648
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	1649 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	1650 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	1651 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	1652 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	1653 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	1654
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1655 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	1656 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	1657 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	1658 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	1659
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1661 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1662
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	1663 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	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 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	1666 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	1667 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1669 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	1670 {
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	1671 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	1672 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	1673 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	1674 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	1675 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1677 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	1678 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	1679 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	1680 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	1681 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	1682 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	1683 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	1684 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1685
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	1686 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	1687 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1689 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	1690 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1692 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	1693 {
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	1694 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	1695 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	1696 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	1697 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	1698 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1700 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	1701 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	1702 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	1703 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	1704 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	1705 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	1706 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	1707 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1710 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1712
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1714 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	1715
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1717 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1718
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	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 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	1721 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1723 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	1724 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1727 {
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	1728 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	1729 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	1730 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	1731 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1732 }
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	1733 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	1734 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	1735 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1738 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1740 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	1741 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1742
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	1743 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	1744 {
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	1745 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	1746 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	1747 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	1748 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1749 }
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	1750 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	1751 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	1752 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1753
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1755 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1757 return debug_int(psg->volume[index]);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1758 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1759
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	1760 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	1761 {
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	1762 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	1763 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	1764 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	1765 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	1766 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1768 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	1769 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1772 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1773 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	1774
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1776 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	1777 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	1778
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 return root;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1780 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1781
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1782 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	1783 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1784 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1785 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1786 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1787 free(full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1788 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1789
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1790 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	1791 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1792 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1793 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	1794 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1795 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1796 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1797 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1798 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1799 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1800 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1801 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	1802 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	1803 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1804 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1805 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1806 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1807 if (node->left \|\| node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1808 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1809 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1810 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1811 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1812 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1813 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1814 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1815 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1816 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1817 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1818 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	1819 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	1820 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1821 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1822 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1823 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1824 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	1825 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1826 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1827 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1828 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1829 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1830 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1831 while (cur && !isspace(cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1832 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1833 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1834 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1835 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1836 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1837 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1838 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1839 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1840 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1841 if (cur && cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1842 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1843 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1844 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	1845 if (def->raw_args) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1846 while (cur && cur != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1847 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1848 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1849 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1850 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1851 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1852 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1853 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1854 raw_param[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1855 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1856 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1857 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1858 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1859 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1860 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1861 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1862 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1863 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1864 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	1865 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1866 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1867 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	1868 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1869 while (text && text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1870 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1871 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1872 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1873 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1874 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1875 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1876 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1877 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	1878 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1879 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1880 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1881 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	1882 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1883 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1884 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1885 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	1886 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	1887 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	1888 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1889 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1890 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1891 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1892 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1893 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1894 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	1895 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1896 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1897 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1898 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1899 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1900 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1901 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1902 out->format = format;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1903
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1904 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1905 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1906 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1907 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	1908 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1909 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1910 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1911 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1912 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	1913 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1914 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1915 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1916 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1917 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1918
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1919 static 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	1920 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	1921 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1922 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	1923 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1924 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	1925 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1926 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	1927 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1928
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1929 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	1930 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1931 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1932 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1933 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	1934 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1935 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1936 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1937 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1938 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	1939 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	1940 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1941 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1942
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1943 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	1944 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	1945 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	1946 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	1947 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	1948 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	1949 };
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1950
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1951 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	1952 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1953 ++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	1954 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	1955 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1956 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	1957 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1958 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	1959 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	1960 #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	1961 #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	1962 #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	1963 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	1964 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	1965 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	1966 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	1967 #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	1968 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	1969 process_events();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	1970 #ifndef IS_LIB
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	1971 render_update_display();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	1972 #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	1973 #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	1974 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	1975 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	1976 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	1977 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	1978 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	1979 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1980 #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	1981 } 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	1982
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1983 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	1984 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	1985 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	1986 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	1987 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1988 char *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	1989 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	1990 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	1991 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1992 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	1993 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	1994 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	1995 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1996 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	1997 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	1998 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1999 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2000 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	2001 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	2002 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	2003 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2004 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	2005 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	2006 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	2007 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	2008 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	2009 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2010 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	2011 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	2012 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	2013 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2014 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	2015 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2016 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	2017 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	2018 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	2019 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	2020 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	2021 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	2022 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	2023 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	2024 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	2025 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	2026 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	2027 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2028 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	2029 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	2030 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	2031 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2032 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	2033 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	2034 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	2035 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	2036 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2037 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2038 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2039 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	2040 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2041
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2042 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	2043 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2044 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	2045 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	2046 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2047 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	2048 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	2049 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	2050 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2051 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2052 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2053 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	2054 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2055
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2056 static 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	2057 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2058
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2059 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	2060 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	2061 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	2062 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	2063 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	2064 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	2065 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	2066 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2067 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	2068 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	2069 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2070 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	2071 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	2072 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	2073 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	2074 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	2075 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	2076 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2077 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	2078 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	2079 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	2080 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	2081 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	2082 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2083 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	2084 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2085 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2086 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	2087 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	2088 } else {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2089 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	2090 }
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2091 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	2092 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2093
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2094 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	2095 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2096 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2097 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2098
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2099 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2100 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2101 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2102 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2103
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2104 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	2105 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2106 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2107 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2108 return;
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 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2111 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2112 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2113 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2114 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2115 state->longest_command = len;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2116 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2117 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2118
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2119 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	2120 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2121 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2122 def->visited = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2123 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2124
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2125 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	2126 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2127 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2128 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2129 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2130 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2131 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2132 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2133 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2134 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2135 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2136 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2137 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2138 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2139 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	2140 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2141 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2142 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2143 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2144 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2145 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2146 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	2147 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2148 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2149 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2150 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2151 split_point = remaining;
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 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2154 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	2155 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2156 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2157 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2158 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2159 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2160 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2161 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2162 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2163 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2164 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2165 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2166 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2167 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2168 putchar(',');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2169 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2170 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	2171 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2172 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2173 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2174 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2175 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2176 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2177 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2178 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2179 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2180 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2181 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2182 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	2183 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2184 fputs(extra_desc, stdout);
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 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2187 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2188
2188 e17d99c96c89 Make blocks an 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 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	2190 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2191 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2192 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	2193 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	2194 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	2195 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	2196 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2197 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2198
2188 e17d99c96c89 Make blocks an 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 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	2200 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2201 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2202 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2203
2188 e17d99c96c89 Make blocks an 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 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	2205 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2206 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2207 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2208 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2209 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2210 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2211 case 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2212 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2213 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2214 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2215 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2216 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2217 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2218 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	2219 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2220 }
2188 e17d99c96c89 Make blocks an 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 }
e17d99c96c89 Make blocks an 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
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	2223 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	2224 {
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	2225 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	2226 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2227 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	2228 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	2229 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	2230 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	2231 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	2232 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	2233 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2234 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	2235 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	2236 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	2237 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	2238 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	2239 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2240 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	2241 }
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	2242 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	2243 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	2244 } 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	2245 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	2246 }
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	2247 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	2248 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	2249 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	2250 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	2251 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	2252 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	2253 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	2254 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2255 }
e17d99c96c89 Make blocks an 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 }
e17d99c96c89 Make blocks an 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 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	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 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	2261 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	2262 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	2263 {
2188 e17d99c96c89 Make blocks an 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 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	2265 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2266 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2267 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2268
2188 e17d99c96c89 Make blocks an 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 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	2270 {
2188 e17d99c96c89 Make blocks an 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 char *param = cmd->raw;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2272 if (!param) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2273 fputs("printf requires at least one parameter\n", stderr);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2274 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2275 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2276 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2277 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2278 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2279 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2280 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2281 fprintf(stderr, "First parameter to printf must be a string, found '%s'\n", param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2282 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2283 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2284 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2285 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2286 char cur = param, out = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2287 while (cur && cur != '"')
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2288 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2289 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2290 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2291 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2292 case 't':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2293 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2294 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2295 case 'n':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2296 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2297 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2298 case 'r':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2299 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2300 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2301 case '\\':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2302 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2303 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2304 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2305 fprintf(stderr, "Unsupported escape character %c in string %s\n", cur[1], fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2306 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2307 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2308 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2309 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2310 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2311 (out++) = (cur++);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2312 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2313 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2314 *out = 0;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2315 ++cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2316 param = cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2317 cur = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2318 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2319 while (*cur)
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2320 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2321 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2322 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2323 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2324 case 'x':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2325 case 'X':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2326 case 'c':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2327 case 'd':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2328 case 's':
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2329 case 'f':
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2330 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2331 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2332 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	2333 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2334 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2335 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2336 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2337 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2338 if (!arg) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2339 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2340 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2341 }
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	2342 debug_val val;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2343 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2344 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2345 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2346 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2347 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	2348 if (val.type == DBG_VAL_STRING) {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2349 //TODO: implement me
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2350 } 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	2351 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	2352 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	2353 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	2354 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	2355 free(fmt);
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2356 return 1;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2357 }
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	2358 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	2359 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	2360 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2361 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	2362 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	2363 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	2364 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	2365 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	2366 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2367 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	2368 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2369 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	2370 printf(format_str, tmp);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2371 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2372 } else if (cur[1] == 'f') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2373 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2374 if (!debug_cast_float(val, &fval)) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2375 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	2376 free(fmt);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2377 return 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2378 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2379 printf(format_str, fval);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2380 } 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	2381 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	2382 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	2383 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	2384 free(fmt);
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2385 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	2386 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2387 printf(format_str, ival);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2388 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2389 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2390 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2391 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2392 ++cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2393 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2394 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2395 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2396 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2397
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2398 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	2399 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2400 cmd_print(root, cmd);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2401 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	2402 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2403 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	2404 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	2405 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	2406 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	2407 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	2408 cmd->num_args = 0;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2409 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2410 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	2411 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2412 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2413
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2414 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	2415 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2416 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	2417 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	2418 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	2419 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	2420 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	2421 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2422 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2423 {
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	2424 if ((*cur)->index == index) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2425 disp_def del_disp = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2426 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2427 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2428 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	2429 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2430 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2431 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	2432 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2433 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2434 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2435 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2436 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2437 cur = &(*cur)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2438 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2439 }
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_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	2444 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2445 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2446 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2447 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2448 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2449 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	2450 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2451 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2452 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2453
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2454 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	2455 {
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	2456 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	2457 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	2458 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	2459 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	2460 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2461 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	2462 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	2463 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	2464 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2465 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2466 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	2467 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2468 free_parsed_command((*target)->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2469 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2470 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	2471 (*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	2472 (*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	2473 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	2474 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	2475 return 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2476 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2477
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2478 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	2479 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2480 uint8_t debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2481 for (int i = 0; i < block->num_commands; i++)
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2482 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2483 debugging = run_command(root, block->commands + i) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2484 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2485 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2486 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2487
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2488 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	2489 {
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	2490 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	2491 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2492
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2493 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	2494 {
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	2495 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	2496 return execute_block(root, &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2497 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2498 int debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2499 do {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2500 debugging = execute_block(root, &cmd->block) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2501 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	2502 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	2503 return 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2504 }
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	2505 } 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	2506 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2507 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2508
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2509 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2510 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2511 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2512 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2513 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2514 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2515 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2516 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2517
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2518 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	2519 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2520 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2521 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	2522 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	2523 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	2524 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	2525 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2526 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	2527 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	2528 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	2529 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	2530 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2531 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	2532 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2533 debug_val address;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2534 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	2535 switch (set_expr->type)
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2536 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2537 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	2538 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	2539 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	2540 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2541 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	2542 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2543 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2544 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2545 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	2546 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	2547 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	2548 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	2549 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2550 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	2551 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2552 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2553 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2554 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	2555 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	2556 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	2557 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	2558 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2559 }
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	2560 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	2561 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	2562 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	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 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	2565 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	2566 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	2567 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	2568 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2569 array = get_array(right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2570 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	2571 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	2572 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2573 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2574 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	2575 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	2576 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2577 }
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	2578 if (address.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	2579 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	2580 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2581 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2582 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2583 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2584 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	2585 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	2586 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2587 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2588 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	2589 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	2590 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2591 }
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	2592 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	2593 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	2594 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	2595 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	2596 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	2597 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	2598 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2599 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	2600 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	2601 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2602 }
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	2603 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	2604 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	2605 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	2606 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	2607 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	2608 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	2609 } 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	2610 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	2611 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	2612 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	2613 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2614 }
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	2615 var->set(var, value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2616 } 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	2617 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	2618 } else if (!root->write_mem(root, address.v.u32, value.v.u32, 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	2619 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	2620 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2621 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2622 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2623
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	2624 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	2625 {
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	2626 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	2627 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	2628 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	2629 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2630 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	2631 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	2632 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	2633 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	2634 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2635 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	2636 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2637 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	2638 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	2639 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	2640 }
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	2641 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	2642 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	2643 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	2644 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	2645 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2646 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	2647 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	2648 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	2649 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	2650 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	2651 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	2652 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	2653 }
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	2654 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	2655 }
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	2656 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	2657 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	2658 }
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	2659
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2660 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	2661 {
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	2662 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	2663 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	2664 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	2665 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2666 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	2667 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	2668 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	2669 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	2670 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2671 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	2672 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2673 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	2674 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	2675 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2676 }
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	2677 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	2678 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	2679 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	2680 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	2681 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	2682 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	2683 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	2684 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	2685 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2686 } 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	2687 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	2688 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	2689 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	2690 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	2691 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	2692 array = get_array(var->val);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2693 }
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	2694 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	2695 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	2696 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	2697 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	2698 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	2699 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2701 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	2702 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2703 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	2704 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	2705 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2706 }
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	2707 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	2708 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2709 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2710 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2711
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2712 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	2713 {
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	2714 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	2715 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	2716 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	2717 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2718 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2719 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	2720 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	2721 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2722 }
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	2723 array->append(array, cmd->args[1].value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2724 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2725 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2726
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2727 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	2728 {
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	2729 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	2730 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	2731 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	2732 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	2733 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2734 current_system->enter_debugger_frames = frames;
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2735 return 0;
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2736 }
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2737
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2738 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	2739 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2740 if (!bind_up(cmd->raw)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2741 fprintf(stderr, "%s is not a valid binding name\n", cmd->raw);
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2742 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2743 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2744 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2745
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2746 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	2747 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2748 if (!bind_down(cmd->raw)) {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2749 fprintf(stderr, "%s is not a valid binding name\n", cmd->raw);
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2750 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2751 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2752 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2753
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2754 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	2755 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2756 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	2757 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	2758 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2759 }
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	2760 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	2761 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	2762 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	2763 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	2764 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2766 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	2767 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	2768 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2769 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2770 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	2771 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	2772 (*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	2773 cmd->args[1].parsed = NULL;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2774 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2775 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2776 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2777 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2778 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2779
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2780 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	2781 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2782 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	2783 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	2784 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	2785 *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	2786 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2787 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2788
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2789 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	2790 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2791 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	2792 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	2793 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	2794 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	2795 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2796 putchar(' ');
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2797 len++;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2798 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2799 printf("%X\n", (uint32_t)val.intval);
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2800 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2801
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2802 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	2803 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2804 char *filename = cmd->raw ? strip_ws(cmd->raw) : NULL;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2805 if (filename && *filename) {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2806 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	2807 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	2808 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	2809 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	2810 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2811 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	2812 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	2813 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2814 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	2815 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	2816 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	2817 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	2818 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	2819 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	2820 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	2821 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	2822 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	2823 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2824 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2825 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2826 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2827 } else {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2828 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	2829 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	2830 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	2831 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	2832 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2833 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	2834 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2835
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2836 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	2837 {
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	2838 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	2839 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	2840 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	2841 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	2842 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2843 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	2844 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	2845 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	2846 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2847 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2848 bp_def tmp = this_bp;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2849 if (tmp->type == BP_TYPE_CPU) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2850 remove_breakpoint(root->cpu_context, tmp->address);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2851 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2852 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2853 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2854 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	2855 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2856 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2857 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2858 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2859 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2860 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2861 return 1;
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
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2864 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	2865 {
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	2866 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	2867 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	2868 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	2869 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	2870 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2872 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	2873 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	2874 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2875 new_bp->mask = 0xFFFFFF;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2876 new_bp->index = root->bp_index++;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2877 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	2878 root->breakpoints = new_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	2879 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	2880 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2881 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2882
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2883 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	2884 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2885 value &= 0xFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2886 if (context->regs[reg] == value) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2887 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2888 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2889 genesis_context gen = (genesis_context )context->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2890 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	2891 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	2892 int debugging = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2893 if (*this_bp) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2894 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	2895 debug_val condres;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2896 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	2897 if (!condres.v.u32) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2898 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2899 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2900 } else {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2901 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	2902 free_expr((*this_bp)->condition);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2903 (*this_bp)->condition = NULL;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2904 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2905 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2906 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	2907 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2908 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	2909 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2910 if (debugging) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2911 printf("VDP Register Breakpoint %d hit on register write %X - Old: %X, New: %X\n", (*this_bp)->index, reg, context->regs[reg], value);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2912 gen->header.enter_debugger = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2913 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	2914 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	2915 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2916 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	2917 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	2918 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2919 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2920 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2921 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2922
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2923 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	2924 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2925 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	2926 new_bp->next = root->breakpoints;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2927 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	2928 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	2929 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	2930 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	2931 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2933 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	2934 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	2935 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	2936 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	2938 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	2939 }
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2940 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2941 new_bp->index = root->bp_index++;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2942 new_bp->type = BP_TYPE_VDPREG;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2943 root->breakpoints = new_bp;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2944 m68k_context *m68k = root->cpu_context;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2945 genesis_context *gen = m68k->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2946 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	2947 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	2948 return 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2949 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2950
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2951 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	2952 {
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	2953 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	2954 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	2955 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	2956 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	2957 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2959 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2960 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2961
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2962 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	2963 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2964 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2965 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2966 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2967 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2968 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	2969 } 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	2970 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	2971 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2972 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	2973 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2974 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	2975 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	2976 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2977 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2978 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	2979 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	2980 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2981 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2982 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2983 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	2984 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	2985 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2986 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2987 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	2988 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2989 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2990 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	2991 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2992 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2993
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2994 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	2995 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2996 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2997 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2998 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2999 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3000 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	3001 } 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	3002 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	3003 } 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	3004 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	3005 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	3006 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3007 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3008 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3009 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3010 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	3011 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3012 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3013 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	3014 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3015 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3016 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3017 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3018 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3019 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3020 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	3021 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3022 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3023 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3024 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	3025 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3026 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3027 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	3028 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3029 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3030
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3031 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	3032 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3033 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3034 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3035 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3036 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3037 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	3038 } 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	3039 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	3040 } 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	3041 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	3042 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3043 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	3044 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	3045 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3046 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3047 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	3048 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	3049 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3050 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3051 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3052 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	3053 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	3054 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3055 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3056 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	3057 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3058 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3059 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	3060 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3061 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3062
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3063 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	3064 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3065 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3066 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3067 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3068 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3069 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	3070 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	3071 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3072 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3073 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3074 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3075 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3076 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	3077 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3078 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	3079 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3080 //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	3081 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3082 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3083 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3084 //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	3085 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3086 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3087 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3088
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3089 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	3090 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3091 m68k_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3092 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3093 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	3094 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	3095 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	3096 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	3097 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3098 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3099 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3100 m68kinst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3101 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3102 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3103 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3104 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	3105 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3106 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3107 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3108 }
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	3109
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3110 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3111 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3112 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3113 } while(!m68k_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3114 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3115 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3116
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3117 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	3118 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3119 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3120 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3121 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3122 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3123 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3124
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3125 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	3126 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3127 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3128 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3129 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3130 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3131 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3132
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3133 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	3134 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3135 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3136 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	3137 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	3138 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	3139 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3140 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	3141 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	3142 }
2173 894c7873a2b1 Consume all expressions in debugger print command Michael Pavone <pavone@retrodev.com> parents: 2172 diff changeset	3143 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3144 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3145 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3146
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3147 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	3148 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3149 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3150 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3151 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3152 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3153 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3154
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3155 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	3156 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3157 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3158 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3159 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3160 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3161 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3162 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3163 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3164 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3165 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	3166 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3167 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	3168 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3169 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	3170 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3171 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3172 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	3173 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3174 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3175 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	3176 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3177 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3178 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3179 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3180 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3181 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3182 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3183
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3184 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	3185 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3186 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3187 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3188 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3189 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3190 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3191 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3192 segacd_context *cd = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3193
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3194 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	3195 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3196 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	3197 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3198 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	3199 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3200 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3201 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	3202 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3203 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3204 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	3205 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3206 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3207 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3208 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3209 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3210 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3211 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3212
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3213 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	3214 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3215 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3216 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3217 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3218 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3219 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3220 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3221 genesis_context *gen = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3222
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3223 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	3224 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3225 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	3226 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3227 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	3228 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3229 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3230 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	3231 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3232 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3233 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	3234 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3235 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3236 } else {
2184 408fb8a7e990 Implement argumentless variant of z80 debugger command Michael Pavone <pavone@retrodev.com> parents: 2183 diff changeset	3237 gen->enter_z80_debugger = 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3238 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3239 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3240 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3241
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3242 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3243 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3244 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3245 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3246 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3247 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3248 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3249 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3250 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3251 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3252 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3253 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3254 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3255 "help", "?", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3256 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3257 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3258 .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	3259 .impl = cmd_help,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3260 .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	3261 .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	3262 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3263 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3264 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3265 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3266 "continue", "c", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3267 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3268 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3269 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3270 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3271 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3272 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3273 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3274 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3275 .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	3276 "print", "p", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3277 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3278 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3279 .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	3280 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3281 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3282 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3283 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3284 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3285 .names = (const char *[]){
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3286 "printf", NULL
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3287 },
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3288 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3289 .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	3290 .impl = cmd_printf,
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3291 .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	3292 .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	3293 .raw_args = 1
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3294 },
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3295 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3296 .names = (const char *[]){
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3297 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3298 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3299 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3300 .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	3301 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3302 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3303 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3304 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3305 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3306 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3307 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3308 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3309 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3310 .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	3311 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3312 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3313 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3314 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3315 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3316 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3317 "deletedisplay", "dd", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3318 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3319 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3320 .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	3321 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3322 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3323 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3324 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3325 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3326 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3327 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3328 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3329 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3330 .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	3331 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3332 .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	3333 .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	3334 .has_block = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3335 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3336 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3337 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3338 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3339 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3340 .usage = "set MEM\|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3341 .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	3342 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3343 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3344 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3345 .skip_eval = 1
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3346 },
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3347 {
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3348 .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	3349 "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	3350 },
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	3351 .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	3352 .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	3353 .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	3354 .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	3355 .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	3356 .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	3357 },
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	3358 {
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	3359 .names = (const char *[]){
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3360 "array", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3361 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3362 .usage = "array NAME [VALUE...]",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3363 .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	3364 .impl = cmd_array,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3365 .min_args = 1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3366 .max_args = -1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3367 .skip_eval = 1
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3368 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3369 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3370 .names = (const char *[]){
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3371 "append", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3372 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3373 .usage = "append NAME VALUE",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3374 .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	3375 .impl = cmd_append,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3376 .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	3377 .max_args = 2
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3378 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3379 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3380 .names = (const char *[]){
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3381 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3382 },
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3383 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3384 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3385 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3386 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3387 .max_args = 1
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3388 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3389 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3390 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3391 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3392 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3393 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3394 .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	3395 .impl = cmd_bindup,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3396 .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	3397 .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	3398 .raw_args = 1
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3399 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3400 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3401 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3402 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3403 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3404 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3405 .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	3406 .impl = cmd_binddown,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3407 .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	3408 .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	3409 .raw_args = 1
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3410 },
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3411 {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3412 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3413 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3414 },
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3415 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3416 .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	3417 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3418 .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	3419 .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	3420 .skip_eval = 1
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3421 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3422 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3423 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3424 "if", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3425 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3426 .usage = "if CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3427 .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	3428 .impl = cmd_if,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3429 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3430 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3431 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3432 .accepts_else = 1
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3433 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3434 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3435 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3436 "while", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3437 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3438 .usage = "while CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3439 .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	3440 .impl = cmd_while,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3441 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3442 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3443 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3444 .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	3445 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3446 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3447 .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	3448 "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	3449 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3450 .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	3451 .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	3452 .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	3453 .min_args = 0,
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3454 .max_args = 1,
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3455 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3456 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3457 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3458 #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	3459
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3460 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3461 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3462 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3463 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3464 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3465 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3466 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3467 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3468 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3469 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3470 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3471 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3472 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3473 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3474 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3475 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3476 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3477 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3478 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3479 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3480 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3481 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3482 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3483 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3484 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3485 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3486 .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	3487 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3488 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3489 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3490 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3491 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3492 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3493 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3494 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3495 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3496 .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	3497 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3498 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3499 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3500 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3501 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3502 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3503 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3504 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3505 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3506 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3507 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3508 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3509 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3510 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3511 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3512 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3513 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3514 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3515 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3516 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3517 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3518 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3519 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3520 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3521 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3522 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3523 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3524 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3525 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3526 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3527 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3528 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3529 .max_args = 1
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3530 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3531 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3532 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3533 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3534 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3535 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3536 .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	3537 .impl = cmd_disassemble_m68k,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3538 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3539 .max_args = 1
2112 3abb64bd0da6 Add support for printing strings in 68K debugger Michael Pavone <pavone@retrodev.com> parents: 2107 diff changeset	3540 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3541 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3542
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3543 #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	3544
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3545 command_def genesis_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3546 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3547 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3548 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3549 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3550 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3551 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3552 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3553 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3554 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3557 .names = (const char *[]){
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3558 "vdpregs", "vr", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3559 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3560 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3561 .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	3562 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3563 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3564 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3565 },
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3566 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3567 .names = (const char *[]){
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3568 "vdpregbreak", "vregbreak", "vrb", NULL
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3569 },
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3570 .usage = "vdpregbreak [REGISTER [MASK]]",
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3571 .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	3572 .impl = cmd_vdp_reg_break,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3573 .min_args = 0,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3574 .max_args = 2
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3575 },
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3576 #ifndef NO_Z80
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3579 "z80", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3580 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3581 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3582 .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	3583 .impl = cmd_gen_z80,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3584 .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	3585 .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	3586 .raw_args = 1
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 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3589 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3590 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3591 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3592 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3593 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3594 .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	3595 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3596 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3597 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3598 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3599 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3600 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3601 "ymtimer", "yt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3602 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3603 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3604 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3605 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3606 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3607 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3608 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3609 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3610
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3611 #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	3612
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3613 command_def scd_main_commands[] = {
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 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3616 "subcpu", NULL
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 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3619 .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	3620 .impl = cmd_sub,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3621 .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	3622 .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	3623 .raw_args = 1
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 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3626
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3627 #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	3628
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3629 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3630 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3631 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3632 "maincpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3633 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3634 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3635 .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	3636 .impl = cmd_main,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3637 .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	3638 .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	3639 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3640 }
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3643 #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	3644
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3645 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3646
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3647 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	3648 {
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	3649 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	3650 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	3651 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	3652 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	3653 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3654 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	3655 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	3656 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	3657 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3658 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3659 bp_def tmp = this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3660 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	3661 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3662 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3663 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	3664 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3665 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3666 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3667 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3668 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3669 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3670 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3671 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3672
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3673 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	3674 {
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	3675 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	3676 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	3677 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	3678 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	3679 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3680 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	3681 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	3682 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	3683 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3684 new_bp->mask = 0xFFFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3685 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	3686 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3687 root->breakpoints = new_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	3688 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	3689 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3690 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3691
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3692 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	3693 {
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	3694 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	3695 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	3696 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	3697 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	3698 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3699 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	3700 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3701 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3702
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3703 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	3704 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3705 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3706 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3707 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3708 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3709 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	3710 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3711 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3712 } 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	3713 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3714 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	3715 } 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	3716 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	3717 } 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	3718 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	3719 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3720 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3721 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3722 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3723 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3724 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	3725 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3726 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3727 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	3728 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3729 after \|= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3730 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3731 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3732 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3733 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	3734 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3735 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3736
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3737 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	3738 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3739 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3740 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3741 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3742
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3743 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	3744 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3745 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3746 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3747 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3748 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3749 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3750 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3751 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3752 } 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	3753 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3754 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	3755 } 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	3756 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	3757 } 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	3758 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	3759 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3760 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3761 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3762 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3763 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3764 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	3765 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3766 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3767 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	3768 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3769 after \|= *sp << 8;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3770 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3771 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3772 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3773 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	3774 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3775 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3776
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3777 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	3778 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3779 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3780 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3781 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3782 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3783 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3784 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	3785 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3786 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3787 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	3788 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3789 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3790 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3791 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3792 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3793 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	3794 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3795 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3796 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	3797 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3798 //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	3799 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3800 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3801 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3802 //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	3803 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3804 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3805 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3806
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3807 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	3808 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3809 z80_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3810 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3811 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	3812 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	3813 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	3814 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	3815 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3816 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3817 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3818 z80inst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3819 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3820 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3821 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3822 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	3823 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3824 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3825 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3826 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3827 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	3828 uint8_t *after = z80_decode(pc, &inst);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3829 z80_disasm(&inst, disasm_buf, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3830 address += after - pc;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3831 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3832 } while(!z80_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3833 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3834 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3835
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3836 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	3837 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3838 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	3839 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	3840 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3841 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3842 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3843 genesis_context gen = (genesis_context )current_system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3844
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3845 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	3846 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	3847 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	3848 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	3849 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	3850 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3851 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3852 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	3853 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3854 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3855 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	3856 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	3857 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3858 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3859 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	3860 return 0;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3861 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3862 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3863
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3864 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	3865 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3866 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	3867 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	3868 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	3869 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3870 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3871
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3872 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	3873 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3874 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	3875 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	3876 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	3877 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3878 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3879
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3880 command_def z80_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3881 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3882 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3883 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3884 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3885 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3886 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3887 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3888 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3889 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3890 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3891 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3892 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3893 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3894 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3895 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3896 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3897 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3898 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3899 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3900 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3901 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3902 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3903 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3904 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3905 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3906 .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	3907 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3908 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3909 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3910 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3911 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3912 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3913 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3914 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3915 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3916 .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	3917 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3918 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3919 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3920 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3921 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3922 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3923 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3924 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3925 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3926 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3927 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3928 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3929 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3930 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3931 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3932 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3933 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3934 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3935 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3936 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3937 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3938 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3939 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3940 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3941 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3942 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3943 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3944 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3945 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3946 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3947 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3948 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3949 .max_args = 1
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3950 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3951 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3952 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3953 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3954 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3955 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3956 .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	3957 .impl = cmd_disassemble_z80,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3958 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3959 .max_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3960 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3961 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3962
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3963 #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	3964
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3965 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	3966 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3967 .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	3968 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3969 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3970 .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	3971 .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	3972 .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	3973 .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	3974 .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	3975 .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	3976 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3977 };
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3978
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3979 #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	3980
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3981 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	3982 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3983 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3984 "vdpsprites", "vs", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3985 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3986 .usage = "vdpsprites",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3987 .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	3988 .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	3989 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3990 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3991 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3992 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3993 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3994 "vdpsregs", "vr", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3995 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3996 .usage = "vdpregs",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3997 .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	3998 .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	3999 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4000 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4001 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4002 };
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4003
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4004 #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	4005
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4006 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4007
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4008 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	4009 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4010 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	4011 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4012 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	4013 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4014 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	4015 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4016 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4017 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4018
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4019 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	4020 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4021 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	4022 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	4023 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	4024 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4025 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	4026 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4027 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4028
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	4029 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	4030 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4031 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	4032 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	4033 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4034
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4035 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	4036 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4037 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4038 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4039 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	4040 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	4041 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4042 root->write_mem = write_m68k;
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4043 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	4044 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	4045 debug_var *var;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4046 switch (current_system->type)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4047 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4048 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4049 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4050 //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	4051 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	4052 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	4053 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	4054 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	4055 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	4056 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	4057 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	4058 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	4059 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	4060 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	4061 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	4062 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	4063 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	4064 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	4065 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	4066 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	4067 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4068 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4069 } 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	4070 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	4071 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	4072 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	4073 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	4074 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4075 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	4076 break;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4077 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4078 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	4079 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4080 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	4081 }
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	4082
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	4083 #ifndef NO_Z80
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4084
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4085 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	4086 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4087 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4088 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4089 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	4090 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4091 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	4092 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4093 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4094 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4095
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4096 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	4097 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4098 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4099 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	4100 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4101 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	4102 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4103 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4104 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4105
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	4106 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	4107 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4108 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	4109 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	4110 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4111
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4112 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	4113 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4114 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	4115 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	4116 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	4117 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	4118 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	4119 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4120 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	4121 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4122
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4123
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4124 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	4125 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4126 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	4127 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	4128 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4129
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4130 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	4131 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4132 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	4133 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	4134 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	4135 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	4136 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	4137 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4138 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	4139 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4140
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4141 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	4142 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4143 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	4144 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	4145 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	4146 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	4147 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	4148 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	4149 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	4150 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	4151 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	4152 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	4153 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4154
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4155 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	4156 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4157 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	4158 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	4159 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	4160 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	4161 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	4162 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	4163 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	4164 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	4165 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	4166 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	4167 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4168
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4169 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	4170 {
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	4171 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	4172 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	4173 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	4174 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	4175 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	4176 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4177 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	4178 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	4179 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	4180 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	4181 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	4182 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	4183 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4184
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4185 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	4186 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4187 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	4188 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	4189 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	4190 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	4191 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	4192 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4193 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	4194 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	4195 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	4196 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	4197 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	4198 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	4199 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4200
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4201 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	4202 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4203 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	4204 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	4205 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	4206 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	4207 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	4208 } 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	4209 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	4210 }
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	4211 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	4212 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4213
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4214 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	4215 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4216 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	4217 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	4218 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	4219 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	4220 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	4221 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4222 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	4223 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	4224 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	4225 } 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	4226 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	4227 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	4228 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4229 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4230
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4231 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	4232 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4233 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	4234 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	4235 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	4236 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	4237 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	4238 } 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	4239 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	4240 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4241 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	4242 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4243
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4244 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	4245 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4246 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	4247 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	4248 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	4249 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	4250 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	4251 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4252 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	4253 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	4254 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	4255 } 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	4256 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	4257 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	4258 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4259 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4260
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	4261 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	4262 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4263 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	4264 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	4265 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4266
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4267 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	4268 {
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	4269 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	4270 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	4271 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	4272 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	4273 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	4274 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4275 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	4276 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4277
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4278 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	4279 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4280 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	4281 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	4282 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	4287 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	4288 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	4289 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	4290 return;
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4291 }
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	4292 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	4293 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4294
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4295 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	4296 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4297 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	4298 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	4299 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4300
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4301 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	4302 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4303 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	4304 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	4305 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4306
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4308 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4310 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4313 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	4314 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4316 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	4317 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4318
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4319 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	4320 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4321 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	4322 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	4323 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4324
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4325 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	4326 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4328 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	4329 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4330
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	4331 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	4332 {
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	4333 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	4334 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	4335 {
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	4336 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	4337 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	4338 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	4339 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	4340 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	4341 } 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	4342 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	4343 var->set = z80_sp_set;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4344 } 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	4345 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	4346 var->set = z80_regpair_set;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4347 }
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	4348 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	4349 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	4350 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	4351 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	4352 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	4353 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	4354 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4355 d = toupper(c);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4356 }
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	4357 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	4358 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	4359
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4360 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	4361 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	4362 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	4363 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	4364 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	4365 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	4366 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	4367 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	4368 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	4369 } 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	4370 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	4371 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	4372 }
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	4373 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	4374 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	4375 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	4376 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	4377 {
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	4378 d = toupper(c);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4379 }
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	4380 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	4381 }
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	4382 free(name);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4383 }
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	4384 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	4385 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	4386 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	4387 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	4388 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	4389 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	4390 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	4391 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	4392 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	4393 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	4394 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	4395 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	4396 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	4397 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	4398 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	4399 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	4400 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	4401 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	4402 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	4403 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	4404 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	4405 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	4406 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	4407 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	4408 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	4409 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	4410 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	4411 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	4412 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	4413 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	4414 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	4415 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	4416 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	4417 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	4418 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	4419 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	4420 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	4421 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4422
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4423 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	4424 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4425 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4426 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4427 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	4428 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	4429 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	4430 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	4431 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	4432 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	4433 //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	4434 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	4435 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4436 case SYSTEM_GENESIS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4437 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	4438 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	4439 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	4440 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	4441 //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	4442 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4443 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	4444 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	4445 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	4446 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	4447 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	4448 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	4449 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	4450 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	4451 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	4452 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	4453 //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	4454 //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	4455 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4456 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4457 root->write_mem = write_z80;
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4458 root->disasm = create_z80_disasm();
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4459 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4460 return root;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4461 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4462
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4463 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	4464 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4465 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4466 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4467 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	4468 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	4469 init_terminal();
2180 b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor Michael Pavone <pavone@retrodev.com> parents: 2179 diff changeset	4470 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	4471 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	4472 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	4473 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4474 root->address = address;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4475 //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	4476 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	4477 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4478 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	4479 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4480 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	4481 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4482 return context;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4483 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4484 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4485 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	4486 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4487 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4488 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4489 }
2208 3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4490 int debugging = 1;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4491 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	4492 {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4493 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	4494 }
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4495 if (debugging) {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4496 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	4497 } else {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4498 return context;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4499 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4500 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4501 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4502 }
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	4503 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	4504 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode Michael Pavone <pavone@retrodev.com> parents: 1111 diff changeset	4505 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	4506 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4507 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	4508 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	4509 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	4510 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	4511 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	4512 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	4513 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4514 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4515 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4516 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	4517 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	4518 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4519 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4520
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4521 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4522 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	4523 debugger_repl(root);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4524 return context;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4525 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4526
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4527 #endif
a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4528
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	4529 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	4530 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4531 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4532 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4533 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	4534
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	4535 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	4536
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	4537 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	4538 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4539 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4540 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4541 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4542 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	4543 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	4544 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	4545 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4546 //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	4547 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	4548 if (address == root->branch_t) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4549 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	4550 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	4551 remove_breakpoint(context, root->branch_f);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4552 }
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	4553 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	4554 } else if(address == root->branch_f) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4555 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	4556 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	4557 remove_breakpoint(context, root->branch_t);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4558 }
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	4559 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	4560 }
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	4561
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4562 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	4563 int debugging = 1;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4564 //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	4565 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	4566 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4567 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	4568 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4569 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	4570 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4571 return;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4572 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4573 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4574 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	4575 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4576 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4577 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4578 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4579 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	4580 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4581 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	4582 }
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit Michael Pavone <pavone@retrodev.com> parents: 829 diff changeset	4583 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	4584 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	4585 } 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	4586 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	4587 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4588 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4589 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4590 }
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4591 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	4592 root->after = after;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4593 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	4594 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	4595 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	4596 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4597 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4598 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4599 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	4600 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	4601 }
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	4602 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4603 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	4604 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	4605 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	4606 return;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4607 }

Mercurial > repos > blastem

annotate debug.c @ 2365:8c060849a503