repos/blastem: debug.c annotate

annotate debug.c @ 2366:1e36d8a2633c

Add missing math.h include

author	Michael Pavone <pavone@retrodev.com>
date	Wed, 08 Nov 2023 23:47:47 -0800
parents	8c060849a503
children	48cc69b4c358

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>
2366 1e36d8a2633c Add missing math.h include Michael Pavone <pavone@retrodev.com> parents: 2365 diff changeset	8 #include <math.h>
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 #include <stdlib.h>
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	10 #include <string.h>
745 daa31ee7d8cd Get windows build compiling again post-merge Michael Pavone <pavone@retrodev.com> parents: 723 diff changeset	11 #ifndef _WIN32
723 7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger Michael Pavone <pavone@retrodev.com> parents: 707 diff changeset	12 #include <sys/select.h>
745 daa31ee7d8cd Get windows build compiling again post-merge Michael Pavone <pavone@retrodev.com> parents: 723 diff changeset	13 #endif
723 7178d750efbd Process events while waiting for 68K debugger input. This prevents "not responsive" dialogs when sitting in the debugger Michael Pavone <pavone@retrodev.com> parents: 707 diff changeset	14 #include "render.h"
792 724bbec47f86 Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows). Michael Pavone <pavone@retrodev.com> parents: 747 diff changeset	15 #include "util.h"
794 792be135d3af Spawn a terminal for the debugger when needed if we are not already attached to one Michael Pavone <pavone@retrodev.com> parents: 792 diff changeset	16 #include "terminal.h"
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	17 #include "z80inst.h"
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	18 #ifndef NO_Z80
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	19 #include "sms.h"
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	20 #endif
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	21
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	22 #ifdef NEW_CORE
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	23 #define Z80_OPTS opts
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	24 #else
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	25 #define Z80_OPTS options
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1630 diff changeset	26 #endif
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	27
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	28 static debug_func *funcs;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	29 static uint32_t num_funcs, func_storage;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	30
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	31 static debug_func* alloc_func(void)
2107 f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU Michael Pavone <pavone@retrodev.com> parents: 2104 diff changeset	32 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	33 if (num_funcs == func_storage) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	34 func_storage = func_storage ? func_storage * 2 : 4;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	35 funcs = realloc(funcs, sizeof(debug_func) * func_storage);
2107 f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU Michael Pavone <pavone@retrodev.com> parents: 2104 diff changeset	36 }
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	37 return funcs + num_funcs++;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	38 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	39
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	40 static debug_val new_native_func(debug_native_func impl, int max_args, int min_args)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	41 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	42 debug_func *f = alloc_func();
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	43 f->impl.native = impl;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	44 f->max_args = max_args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	45 f->min_args = min_args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	46 f->is_native = 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	47 return (debug_val) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	48 .v = {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	49 .u32 = f - funcs
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	50 },
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	51 .type = DBG_VAL_FUNC
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	52 };
2107 f80c6111e1ae Move some debugger state to a per-CPU structure. Add m command for returning to main CPU from sub CPU Michael Pavone <pavone@retrodev.com> parents: 2104 diff changeset	53 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	54
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	55 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	56 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	57 return var->val;
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
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	60 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	61 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	62 var->val = val;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	63 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	64
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	65 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	66 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	67 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	68 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	69 var->set = user_var_set;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	70 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	71 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	72 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	73
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	74 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	75 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	76 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	77 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	78 var->set = NULL;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	79 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	80 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	81 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	82
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	84 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	85 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	86 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	88 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	89 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	90 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	95 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	97 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	98 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	99 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	100 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	101 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	102 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	103 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	104 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	105 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	109 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	111 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	115 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	117 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	121 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	122 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	123 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	124 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	125 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	127 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	131 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	133 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	134 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	135 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	136 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	137 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	138 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	139 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	140 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	141 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	145 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	147 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	148 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	150 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	151
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	152 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	153 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	154 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	155 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	156 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	157 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	158 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	159 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	160 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	161 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	162 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	163 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	164
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	165 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	166 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	167 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	168 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	169 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	170 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	171 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	172 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	173 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	174 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	175 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	176 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	177
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	178 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	179 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	180 switch(val.type)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	181 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	182 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	183 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	184 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	185 default: return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	186 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	190 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	192 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	193 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	194 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	195 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	196
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	197 static debug_val debug_float(float f)
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	198 {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	199 return (debug_val) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	200 .type = DBG_VAL_F32,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	201 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	202 .f32 = f
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 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	206
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	207 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	208 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	209 float f;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	210 if (!debug_cast_float(args[0], &f)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	211 return debug_float(0.0f);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	212 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	213 return debug_float(sinf(f));
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
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	216 static debug_root *roots;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	217 static uint32_t num_roots, root_storage;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	218
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	219 debug_root find_root(void cpu)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	220 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	221 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	222 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	223 if (roots[i].cpu_context == cpu) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	224 return roots + i;
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 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	227 if (num_roots == root_storage) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	228 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	229 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	230 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	231 debug_root *root = roots + num_roots++;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	232 memset(root, 0, sizeof(debug_root));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	233 root->cpu_context = cpu;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	234 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	235 return root;
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
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	238 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	239 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	240 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	241 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	242 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	243 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	244 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	245 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	246 return cur;
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
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	249 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	250 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	251 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	252 if ((*cur)->index == index) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	253 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	254 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	255 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	256 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	257 return cur;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	258 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	259
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	260 static const char *token_type_names[] = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	261 "TOKEN_NONE",
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	262 "TOKEN_INT",
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	263 "TOKEN_DECIMAL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	264 "TOKEN_NAME",
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	265 "TOKEN_ARRAY",
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	266 "TOKEN_FUNCALL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	267 "TOKEN_OPER",
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	268 "TOKEN_SIZE",
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	269 "TOKEN_LBRACKET",
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	270 "TOKEN_RBRACKET",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	271 "TOKEN_LPAREN",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	272 "TOKEN_RPAREN"
2169 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
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	275 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	276 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	277 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	278 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	279 ++start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	280 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	281 if (!start \|\| start == '\n' \|\| *start == '\r') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	282 return (token){
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	283 .type = TOKEN_NONE
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	284 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	285 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	286 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	287 if (start == '$' \|\| (start == '0' && start[1] == 'x')) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	288 return (token) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	289 .type = TOKEN_INT,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	290 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	291 .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	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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	295 if (isdigit(*start)) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	296 uint32_t ipart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	297 if (**end == '.') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	298 start = *end + 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	299 uint32_t fpart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	300 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	301 if (fpart) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	302 float divisor = powf(10.0f, *end - start);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	303 fval = ipart + fpart / divisor;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	304 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	305 fval = ipart;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	306 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	307 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	308 .type = TOKEN_DECIMAL,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	309 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	310 .f = fval
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 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	313 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	314 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	315 .type = TOKEN_INT,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	316 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	317 .num = ipart
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 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	320 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	321 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	322 switch (*start)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	323 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	324 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	325 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	326 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	327 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	328 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	329 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 '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	333 case '!':
2191 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 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	336 if ((start == '!' \|\| start == '>' \|\| *start == '<') && start[1] == '=') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	337 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	338 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	339 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	340 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	341 .op = {*start, start[1], 0}
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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	345 *end = start + 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	346 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	347 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	348 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	349 .op = {*start, 0}
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 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	352 case '.':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	353 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	354 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	355 .type = TOKEN_SIZE,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	356 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	357 .op = {start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	358 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	359 };
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	360 case '[':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	361 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	362 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	363 .type = TOKEN_LBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	364 };
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	365 case ']':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	366 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	367 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	368 .type = TOKEN_RBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	369 };
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	370 case '(':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	371 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	372 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	373 .type = TOKEN_LPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	374 };
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	375 case ')':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	376 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	377 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	378 .type = TOKEN_RPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	379 };
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	380 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	381 *end = start + 1;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	382 token_type type = TOKEN_NAME;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	383 while (end && !isspace(end))
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	384 {
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	385 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	386 switch (**end)
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	387 {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	388 case '[':
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	389 type = TOKEN_ARRAY;
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	390 done = 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	391 break;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	392 case '(':
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	393 type = TOKEN_FUNCALL;
2172 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 '=':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	403 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	404 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	405 case '<':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	406 case '.':
2357 344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	407 case ']':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	408 case ')':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	409 done = 1;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	410 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	411 }
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	412 if (done) {
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	413 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	414 }
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	415
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	416 ++*end;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	417 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	418 char name = malloc(end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	419 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	420 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	421 return (token) {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	422 .type = type,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	423 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	424 .str = name
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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	428
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	429 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	430 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	431 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	432 free_expr(e->left);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	433 if (e->type == EXPR_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	434 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	435 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	436 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	437 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	438 free(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	439 } else {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	440 free_expr(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	441 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	442 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	443 free(e->op.v.str);
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 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	446
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	447 static void free_expr(expr *e)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	448 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	449 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	450 return;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	451 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	452 free_expr_int(e);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	453 free(e);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	454 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	455
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	456 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	457 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	458
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	460 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	462 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	463 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 *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	465 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	466 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	467 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	469 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	470 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	471 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	472 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	473 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	474 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	475 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	476 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	477 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	478 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	479 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	480 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	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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	484 //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	485 //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	486 //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	487 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	488 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	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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	491
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	492 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	493 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	494 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	495 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	496 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	497 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	498 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	499 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	500 fprintf(stderr, "Unexpected TOKEN_SIZE '.%s'\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	501 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	502 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	503 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	504 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	505 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	506 fprintf(stderr, "Unary expression %s needs value\n", first.v.op);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	507 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	508 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	509 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	510 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	511 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	512 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	513 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	514 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	515 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	516 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	517 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	518 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	519 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	520 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	521 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	522 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	523 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	524 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	525 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	526 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	527 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	528
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	529 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	530 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	531 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	532 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	533 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	534 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	535 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	536 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	537 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	538 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	539 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	540 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	541 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	542 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	543 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	544 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	545 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	546 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	547 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	548 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	549 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	550 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	551 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	552 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	553 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	554 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	555 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	556 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	557 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	558 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	559 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	560 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	561 return ret;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	562 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	563 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	564 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	565 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	566 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	567 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	568 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	569 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	570 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	571 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	572 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	573 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	574 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	575 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	576 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	577 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	578 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	579 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	580 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	581 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	582 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	583 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	584 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	585 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	586 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	587 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	588 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	589 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	590 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	591 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	592 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	593 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	594 return ret;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	595 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	596 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	597 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	598 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	599 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	600 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	601 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	602 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	603 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	604 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	605 handle_namespace(ret);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	606 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	607 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	608 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	609 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	610 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	611 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	612 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	613 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	614 handle_namespace(ret->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	615 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	616 return ret;
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
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	619 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	620 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	621 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	622 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	623 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	624 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	625 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	626 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	627 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	628 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	629 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	630 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	631 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	632 {
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 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	638 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	639 return maybe_binary(bin, *end, end);
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 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	642 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	643 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	644 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	645 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	646 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	647 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	648 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	649 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	650 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	651 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	652 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	653 return left;
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
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	657 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	658 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	659 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	660 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	661 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	662 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	663 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	664 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	665 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	666 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	667 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	668 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	669 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	670 {
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 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	676 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	677 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	678 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	679 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	680 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	681 return left;
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
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	685 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	686 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	687 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	688 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	689 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	690 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	691 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	692 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	693 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	694 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	695 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	696 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	697 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	698 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	699 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	700 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	701 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	702 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	703 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	704 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	705 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	706 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	707 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	708 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	709 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	710 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	711 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	712 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	713 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	714 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	715 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	716 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	717 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	718 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	719 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	720
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	721 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	722 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	723 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	724 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	725 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	726 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	727 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	728 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	729 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	730 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	731 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	732 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	733 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	734 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	735 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	736 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	737 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	738 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	739 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	740 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	741 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	742 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	743 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	744 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	745 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	746 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	747 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	748 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	749 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	750 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	751 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	752 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	753 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	754 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	755 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	756 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	757 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	758 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	759 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	760 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	761 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	762 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	763 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	764 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	765 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	766 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	767 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	768 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	769 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	770 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	771 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	772 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	773 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	774 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	775 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	776 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	777 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	778 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	779 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	780 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	781 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	782 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	783 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	784 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	785 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	786 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	787 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	788 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	789 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	790 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	791 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	792 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	793 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	794 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	795 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	796 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	797 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	798 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	799 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	800 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	801 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	802 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	803 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	804 {
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 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	810 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	811 return maybe_muldiv(bin, *end, end);
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 '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	815 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	816 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	817 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	818 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	819 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	820 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	821 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	822 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	823 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	824 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	825 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	826 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	827 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	828 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	829 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	830 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	831 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	832 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	833 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	834 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	835 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	836 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	837 } else {
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	838 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	839 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	840 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	841 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	842 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	843 return ret;
2169 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
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	847 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	848 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	849 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	850 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	851 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	852 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	853 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	854 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	855 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	856 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	857 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	858 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	859 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	860 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	861 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	862 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	863 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	864 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	865 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	866 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	867 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	868 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	869 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	870 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	871 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	872 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	873 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	874 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	875 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	876 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	877 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	878 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	879 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	880 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	881 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	882
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	883 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	884 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	885 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	886 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	887 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	888 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	889 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	890 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	891 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	892 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	893 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	894 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	895 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	896 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	897 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	898 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	899 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	900 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	901 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	902 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	903 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	904 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	905 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	906 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	907 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	908 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	909 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	910 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	911 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	912 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	913 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	914 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	915 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	916 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	917 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	918 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	919 ret->type = EXPR_FUNCALL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	920 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	921 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	922 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	923 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	924 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	925 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	926 //consume LPAREN
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	927 parse_token(after_first, end);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	928 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	929 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	930 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	931 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	932 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	933 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	934 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	935 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	936 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	937 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	938 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	939 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	940 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	941 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	942 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	943 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	944 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	945 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	946 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	947 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	948 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	949 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	950 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	951 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	952 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	953 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	954 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	955 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	956 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	957 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	958 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	959 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	960 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	961 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	962 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	963 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	964 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	965 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	966 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	967 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	968 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	969 {
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 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	975 bin->right = parse_scalar(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	976 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	977 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	978 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	979 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	980 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	981 return maybe_binary(bin, *end, end);
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 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	984 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	985 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	986 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	987 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	988 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	989 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	990 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	991 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	992 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	993 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	994 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	995 bin->right = parse_expression(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	996 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	997 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	998 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	999 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1000 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1001 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1002 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1003 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	1004 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1005 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1006 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1007 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1008 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1009 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1010 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1011 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1012 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1013 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1014 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	1015 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1016 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1017 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1018 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1019 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1020 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1021 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1022 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1023 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	1024 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1025 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1026 return ret;
2169 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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1029
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1030 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	1031 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1032 debug_val right;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1033 debug_val *args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1034 debug_func *func;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1035 int num_args;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1036 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1037 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1038 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	1039 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	1040 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	1041 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	1042 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	1043 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 *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	1045 return 1;
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1046 } else if (e->op.type == TOKEN_INT) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1047 *out = debug_int(e->op.v.num);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1048 return 1;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1049 } else {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1050 *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	1051 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1052 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1053 case EXPR_UNARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1054 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	1055 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1056 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1057 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1058 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1059 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	1060 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	1061 out->v.u32 = !out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1062 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1063 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	1064 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	1065 out->v.u32 = ~out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1066 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1067 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	1068 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	1069 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	1070 } 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	1071 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	1072 } 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	1073 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	1074 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	1075 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1076 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1077 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1078 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1079 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1080 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1081 case EXPR_BINARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1082 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	1083 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1084 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 != 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	1086 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	1087 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	1088 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	1089 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	1090 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	1091 } 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	1092 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	1093 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	1094 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	1096 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	1097 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	1098 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	1099 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	1100 } 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	1101 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	1102 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	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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1107 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	1108 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1110 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	1111 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	1112 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	1113 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	1114 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	1115 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	1116 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	1117 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	1118 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	1119 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	1120 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	1121 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	1122 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	1123 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	1124 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	1125 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	1126 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	1127 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	1128 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	1129 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	1130 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	1131 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	1132 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	1133 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	1134 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	1135 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	1136 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	1137 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	1138 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	1139 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	1140 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	1141 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	1142 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	1143 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	1144 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	1146 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	1147 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1149 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	1150 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	1151 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	1152 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	1153 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	1154 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	1155 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	1156 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	1157 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	1158 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	1159 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	1160 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	1161 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	1162 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	1163 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	1164 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	1165 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	1166 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	1167 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	1168 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	1169 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	1170 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	1171 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	1172 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	1173 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	1174 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	1175 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	1176 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	1177 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	1178 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1179 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1180 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1181 case EXPR_SIZE:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1182 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	1183 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1184 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1185 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	1186 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1187 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1188 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	1189 out->v.u32 &= 0xFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1190 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1191 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	1192 out->v.u32 &= 0xFFFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1193 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1194 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1195 return 1;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1196 case EXPR_MEM:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1197 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	1198 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1199 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1200 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	1201 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	1202 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	1203 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	1204 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1206 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	1207 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	1208 return 0;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1209 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1211 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	1212 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1213 *out = array->get(array, out->v.u32);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1214 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1215 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1217 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	1218 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	1219 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	1220 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	1221 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	1222 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1223 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	1224 case EXPR_FUNCALL:
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1225 if (!eval_expr(root, e->left, out)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1226 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1227 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1228 if (out->type != DBG_VAL_FUNC) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1229 fprintf(stderr, "Funcall expression requires function");
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1230 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1231 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1232 func = funcs + out->v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1233 num_args = e->op.v.num;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1234 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	1235 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	1236 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1237 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1238 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	1239 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	1240 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1241 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1242 args = calloc(num_args, sizeof(debug_val));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1243 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	1244 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1245 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	1246 return 0;
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 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1249 if (func->is_native) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1250 *out = func->impl.native(args, num_args);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1251 } else {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1252 //TODO: Implement me
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1253 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1254 return 1;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1255 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1256 return 0;
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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1259
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1260 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1261 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1262 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1263 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1264 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1265 return buf+1;
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 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1269 return NULL;
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
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1272 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1273 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1274 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1275 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1276 *buf = 0;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1277 return;
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 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1281
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	1282 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	1283 {
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 //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	1285 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	1286 }
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	1287
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1288 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	1289 {
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 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	1291 }
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	1292
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1293 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	1294 {
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 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	1296 }
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	1297
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1298 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	1299 {
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1300 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	1301 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1302 out = m68k_read_byte(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1303 } else if (size == 'l') {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1304 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1305 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	1306 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1307 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1308 out = m68k_read_long(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1309 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1310 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1311 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	1312 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1313 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1314 out = m68k_read_word(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1315 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1316 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1317 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1318
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1319 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	1320 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1321 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1322 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1323 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	1324 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1325 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1326 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	1327 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1328 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1329 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	1330 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	1331 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1332 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1333 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	1334 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1335 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1336 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	1337 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1338 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1339 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1340
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1342 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1344 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	1345 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1346
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1347 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	1348 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1350 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	1351 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	1352 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	1353 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	1354 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1355 context->dregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1356 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1357
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1359 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1361 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1364 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	1365 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1367 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	1368 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	1369 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	1370 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	1371 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1372 context->aregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1373 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1374
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1375 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	1376 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1378 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	1379 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	1380 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	1381 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1383 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1385 return ret;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1386 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1387
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1388 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	1389 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1391 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	1392 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	1393 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	1394 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	1395 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1397 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	1398 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	1399 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1400 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1401
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1402 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	1403 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1405 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1409 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1411 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	1412 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1413
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1414 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	1415 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1417 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	1418 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	1419 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	1420 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	1421 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1422 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	1423 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1424
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1425 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	1426 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1427 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	1428 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	1429 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1430
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1431 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	1432 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1434 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	1435 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	1436 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	1437 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1438 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1443 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1445 return debug_int(root->address);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1446 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1447
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1448 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	1449 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1451 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	1452 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1454 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	1455 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	1456 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	1457 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	1458 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	1459 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	1460 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	1461 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	1462
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1464 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	1465 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	1466 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	1467 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	1468 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	1469 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	1470 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	1471 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	1472 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	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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1479 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	1480 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	1481 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	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 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	1484
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1486 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	1487 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	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 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	1490
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1492 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	1493 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	1494 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	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 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	1497
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1499 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	1500 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	1501 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	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 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	1504
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1506 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	1507 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	1508 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	1509 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1510
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1511 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	1512 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1514 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1518 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1520 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	1521 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1522
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1524 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1526 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1529 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	1530 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1532 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	1533 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	1534 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	1535 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	1536 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1541 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1543 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	1544 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1545
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1547 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1549 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	1550 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	1551 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	1552 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	1553 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1558 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1560 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1564 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1566 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1569 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	1570 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1572 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	1573 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	1574 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	1575 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	1577 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1581 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1583 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1587 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1589 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	1590 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	1591 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	1592 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	1594 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1598 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1600 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	1601 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1602
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1604 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1606 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	1607 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	1608 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	1609 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	1611 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1614 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	1615 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1617 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1621 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1623 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	1624 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	1625 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	1626 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1627 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1628 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	1629 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1630
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1631 static 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	1632 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1633 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	1634 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	1635 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	1636 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	1637 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	1638
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1639 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	1640 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	1641 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	1642 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	1643
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1645 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	1646 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	1647 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	1648 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	1649
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1651 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	1652 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	1653 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	1654 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	1655
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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, "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	1657 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	1658 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	1659 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	1660
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1661 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1662 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1663
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1665 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1667 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1670 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	1671 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1673 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	1674 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	1675 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	1676 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1678 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	1679 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	1680 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	1681 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	1682 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	1683 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	1684 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	1685 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1686
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1688 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1690 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1693 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	1694 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1696 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	1697 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	1698 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	1699 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1701 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	1702 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	1703 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	1704 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	1705 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	1706 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	1707 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1711 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1713
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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, "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	1715 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	1716
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1717 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1718 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1719
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1720
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1721 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	1722 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1724 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1727 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	1728 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1730 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	1731 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	1732 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1733 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	1735 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1739 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1741 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	1742 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1743
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1744 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	1745 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1747 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	1748 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	1749 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1750 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	1752 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1756 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1758 return debug_int(psg->volume[index]);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1759 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1760
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1761 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	1762 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1764 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	1765 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	1766 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	1767 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1768 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	1769 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	1770 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1771
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1772 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	1773 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1775
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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, "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	1777 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	1778 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	1779
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1780 return root;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1781 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1782
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1783 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	1784 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1785 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1786 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1787 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1788 free(full);
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1791 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	1792 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1793 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1794 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	1795 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1796 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1797 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1798 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1799 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1800 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1801 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1802 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	1803 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	1804 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1805 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1806 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1807 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1808 if (node->left \|\| node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1809 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1810 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1811 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1812 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1813 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1814 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1815 break;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1818 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1819 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	1820 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	1821 goto cleanup_name;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1824 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1825 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	1826 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1827 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1828 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1829 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1830 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1831 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1832 while (cur && !isspace(cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1833 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1834 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1835 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1836 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1837 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1838 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1839 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1840 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1841 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1842 if (cur && cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1843 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1844 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1845 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	1846 if (def->raw_args) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1847 while (cur && cur != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1848 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1849 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1850 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1851 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1852 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1853 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1854 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1855 raw_param[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1856 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1857 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1858 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1859 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1860 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1861 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1862 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1863 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1864 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1865 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	1866 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1867 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1868 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	1869 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1870 while (text && text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1871 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1872 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1873 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1874 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1875 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1876 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1877 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1878 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	1879 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1880 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1881 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1882 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	1883 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1884 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1885 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1886 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	1887 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	1888 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	1889 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1890 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1891 goto cleanup_args;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1894 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1895 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	1896 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1897 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1898 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1899 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1900 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1901 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1902 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1903 out->format = format;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1904
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1905 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1906 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1907 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1908 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	1909 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1910 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1911 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1912 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1913 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	1914 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1915 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1916 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1917 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1918 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1919
2188 e17d99c96c89 Make blocks an 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_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	1921 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	1922 {
e17d99c96c89 Make blocks an 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 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	1924 {
e17d99c96c89 Make blocks an 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 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	1926 }
e17d99c96c89 Make blocks an 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 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	1928 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	1929
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1930 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	1931 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1932 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1933 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1934 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	1935 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1936 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1937 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1938 }
2188 e17d99c96c89 Make blocks an 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->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	1940 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	1941 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1942 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1943
2188 e17d99c96c89 Make blocks an 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 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	1945 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	1946 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	1947 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	1948 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	1949 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	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
e17d99c96c89 Make blocks an 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 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	1953 {
e17d99c96c89 Make blocks an 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 ++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	1955 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	1956 {
e17d99c96c89 Make blocks an 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 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	1958 }
e17d99c96c89 Make blocks an 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 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	1960 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	1961 #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	1962 #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	1963 #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	1964 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	1965 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	1966 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	1967 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	1968 #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	1969 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	1970 process_events();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	1971 #ifndef IS_LIB
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	1972 render_update_display();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	1973 #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	1974 #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	1975 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	1976 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	1977 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	1978 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	1979 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	1980 }
e17d99c96c89 Make blocks an 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 #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	1982 } 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	1983
e17d99c96c89 Make blocks an 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 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	1985 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	1986 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	1987 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	1988 }
e17d99c96c89 Make blocks an 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 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	1990 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	1991 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	1992 }
e17d99c96c89 Make blocks an 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 (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	1994 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	1995 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	1996 }
e17d99c96c89 Make blocks an 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 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	1998 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	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 }
e17d99c96c89 Make blocks an 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 (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	2002 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	2003 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	2004 }
e17d99c96c89 Make blocks an 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 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	2006 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	2007 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	2008 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	2009 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	2010 {
e17d99c96c89 Make blocks an 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 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	2012 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	2013 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	2014 }
e17d99c96c89 Make blocks an 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 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	2016 {
e17d99c96c89 Make blocks an 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 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	2018 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	2019 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	2020 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	2021 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	2022 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	2023 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	2024 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	2025 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	2026 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	2027 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	2028 }
e17d99c96c89 Make blocks an 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 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	2030 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	2031 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	2032 }
e17d99c96c89 Make blocks an 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 = &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	2034 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	2035 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	2036 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	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 }
e17d99c96c89 Make blocks an 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 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	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
e17d99c96c89 Make blocks an 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 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	2044 {
e17d99c96c89 Make blocks an 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 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	2046 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	2047 {
e17d99c96c89 Make blocks an 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 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	2049 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	2050 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	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 }
e17d99c96c89 Make blocks an 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 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	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
e17d99c96c89 Make blocks an 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 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	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
e17d99c96c89 Make blocks an 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 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	2061 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	2062 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	2063 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	2064 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	2065 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	2066 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	2067 }
2188 e17d99c96c89 Make blocks an 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 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	2069 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	2070 {
e17d99c96c89 Make blocks an 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 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	2072 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	2073 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	2074 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	2075 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	2076 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	2077 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2078 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	2079 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	2080 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	2081 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	2082 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	2083 }
2188 e17d99c96c89 Make blocks an 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 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	2085 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2086 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2087 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	2088 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	2089 } else {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2090 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	2091 }
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2092 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	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
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2095 static uint8_t cmd_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	2096 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2097 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2098 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2099
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2100 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2101 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2102 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2103 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2104
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2105 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	2106 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2107 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2108 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2109 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2110 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2111 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2112 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2113 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2114 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2115 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2116 state->longest_command = len;
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2120 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	2121 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2122 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2123 def->visited = 0;
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2126 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	2127 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2128 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2129 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2130 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2131 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2132 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2133 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2134 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2135 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2136 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2137 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2138 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2139 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2140 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	2141 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2142 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2143 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2144 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2145 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2146 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2147 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	2148 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2149 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2150 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2151 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2152 split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2153 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2154 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2155 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	2156 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2157 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2158 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2159 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2160 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2161 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2162 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2163 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2164 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2165 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2166 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2167 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2168 } else {
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 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2171 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	2172 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2173 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2174 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2175 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2176 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2177 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2178 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2179 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2180 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2181 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2182 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2183 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	2184 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2185 fputs(extra_desc, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2186 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2187 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2188 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2189
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2190 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	2191 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2192 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2193 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	2194 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	2195 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	2196 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	2197 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2198 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2199
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2200 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	2201 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2202 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2203 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2204
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2205 static 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	2206 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2207 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2208 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2209 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2210 {
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 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2213 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2214 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2215 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2216 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2217 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2218 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2219 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	2220 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2221 }
2188 e17d99c96c89 Make blocks an 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 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2223
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2224 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	2225 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2227 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2229 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	2230 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	2231 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	2232 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	2233 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	2234 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2236 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	2237 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	2238 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	2239 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	2240 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2241 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	2242 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2244 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	2245 } 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	2246 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	2247 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2249 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	2250 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	2251 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	2252 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	2253 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	2254 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	2255 }
2188 e17d99c96c89 Make blocks an 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
e17d99c96c89 Make blocks an 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 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	2260 {
e17d99c96c89 Make blocks an 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 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	2262 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	2263 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	2264 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2265 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	2266 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2267 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2268 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2269
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2270 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	2271 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2272 char *param = cmd->raw;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2273 if (!param) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2274 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	2275 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2276 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2277 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2278 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2279 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2280 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2281 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2282 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	2283 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2284 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2285 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2286 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2287 char cur = param, out = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2288 while (cur && cur != '"')
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2289 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2290 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2291 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2292 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2293 case 't':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2294 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2295 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2296 case 'n':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2297 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2298 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2299 case 'r':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2300 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2301 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2302 case '\\':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2303 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2304 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2305 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2306 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	2307 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2308 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2309 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2310 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2311 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2312 (out++) = (cur++);
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 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2315 *out = 0;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2316 ++cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2317 param = cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2318 cur = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2319 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2320 while (*cur)
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2321 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2322 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2323 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2324 {
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 'X':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2327 case 'c':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2328 case 'd':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2329 case 's':
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2330 case 'f':
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2331 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2332 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2333 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	2334 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2335 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2336 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2337 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2338 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2339 if (!arg) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2340 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2341 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2342 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2343 debug_val val;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2344 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2345 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2346 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2347 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2348 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	2349 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	2350 //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	2351 } 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	2352 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	2353 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	2354 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	2355 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	2356 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	2357 return 1;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2358 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2360 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	2361 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2363 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	2364 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	2365 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	2366 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	2367 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2369 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2371 printf(format_str, tmp);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2372 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2373 } else if (cur[1] == 'f') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2374 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2375 if (!debug_cast_float(val, &fval)) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2376 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	2377 free(fmt);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2378 return 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2379 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2380 printf(format_str, fval);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2381 } 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	2382 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	2383 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	2384 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	2385 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	2386 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	2387 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2388 printf(format_str, ival);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2389 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2390 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2391 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2392 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2393 ++cur;
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 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2396 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2397 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2398
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2399 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	2400 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2401 cmd_print(root, cmd);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2402 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	2403 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2404 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	2405 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	2406 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	2407 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	2408 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	2409 cmd->num_args = 0;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2410 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2411 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	2412 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2413 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2414
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2415 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	2416 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2417 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	2418 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	2419 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	2420 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	2421 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	2422 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2423 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2424 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2425 if ((*cur)->index == index) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2426 disp_def del_disp = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2427 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2428 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2429 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	2430 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2431 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2432 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	2433 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2434 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2435 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2436 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2437 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2438 cur = &(*cur)->next;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2441 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2442 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2443
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2444 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	2445 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2446 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2447 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2448 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2449 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2450 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	2451 return 1;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2454
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2455 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	2456 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2458 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	2459 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	2460 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	2461 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2462 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	2463 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	2464 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	2465 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2466 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2467 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	2468 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2469 free_parsed_command((*target)->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2470 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2471 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	2472 (*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	2473 (*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	2474 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	2475 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	2476 return 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2477 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2478
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2479 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	2480 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2481 uint8_t debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2482 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	2483 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2484 debugging = run_command(root, block->commands + i) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2485 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2486 return debugging;
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
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2489 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	2490 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2491 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	2492 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2493
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2494 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	2495 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2496 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	2497 return execute_block(root, &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2498 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2499 int debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2500 do {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2501 debugging = execute_block(root, &cmd->block) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2502 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	2503 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	2504 return 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2505 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2506 } 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	2507 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2508 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2509
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2510 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2511 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2512 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2513 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2514 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2515 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2516 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2517 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2518
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2519 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	2520 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2521 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2522 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	2523 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	2524 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	2525 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	2526 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2528 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	2529 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	2530 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	2531 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2533 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2534 debug_val address;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2535 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	2536 switch (set_expr->type)
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2537 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2538 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	2539 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	2540 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	2541 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2542 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	2543 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2544 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2545 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2546 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	2547 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	2548 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	2549 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	2550 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2551 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	2552 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2553 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2554 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2555 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	2556 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	2557 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	2558 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	2559 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2560 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2561 if (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	2562 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	2563 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	2564 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2566 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	2567 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	2568 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	2569 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2570 array = get_array(right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2571 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	2572 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	2573 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2574 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2575 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	2576 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	2577 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2578 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2580 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	2581 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2582 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2583 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2584 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2585 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	2586 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	2587 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2588 }
2188 e17d99c96c89 Make blocks an 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 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	2590 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	2591 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2592 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2594 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	2595 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	2596 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	2597 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	2598 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	2599 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2601 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	2602 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2603 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2605 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	2606 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	2607 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	2608 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	2609 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	2610 } 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	2611 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	2612 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	2613 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	2614 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2615 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2616 var->set(var, value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2617 } 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	2618 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	2619 } 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	2620 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	2621 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2622 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2623 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2624
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	2625 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	2626 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2628 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	2629 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	2630 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2632 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	2633 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	2634 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	2635 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2637 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2639 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	2640 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	2641 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2643 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	2644 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	2645 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	2646 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2648 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	2649 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	2650 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	2651 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	2652 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	2653 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	2654 }
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 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	2656 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2657 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	2658 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	2659 }
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	2660
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2661 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	2662 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2664 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	2665 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	2666 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2668 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	2669 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	2670 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	2671 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2673 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2675 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	2676 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2677 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	2679 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	2680 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	2681 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	2682 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	2683 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	2684 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	2685 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	2686 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	2688 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	2689 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	2690 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	2691 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	2692 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	2693 array = get_array(var->val);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2694 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2696 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	2697 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	2698 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	2699 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	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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2702 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	2703 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2704 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	2705 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	2706 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2707 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2708 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	2709 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2710 return 1;
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
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2713 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	2714 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2715 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	2716 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	2717 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	2718 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2719 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2720 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	2721 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	2722 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2723 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2724 array->append(array, cmd->args[1].value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2725 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2726 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2727
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2728 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	2729 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2731 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	2732 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	2733 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	2734 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2735 current_system->enter_debugger_frames = frames;
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2736 return 0;
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2737 }
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2738
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2739 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	2740 {
2188 e17d99c96c89 Make blocks an 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 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	2742 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	2743 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2744 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2745 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2746
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2747 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	2748 {
2188 e17d99c96c89 Make blocks an 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 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	2750 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	2751 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2752 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2753 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2754
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2755 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	2756 {
2188 e17d99c96c89 Make blocks an 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 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	2758 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	2759 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2760 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2762 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	2763 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	2764 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	2765 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2766 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	2767 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	2768 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	2769 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2770 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2771 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	2772 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	2773 (*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	2774 cmd->args[1].parsed = NULL;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2775 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2776 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2777 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2778 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2779 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2780
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2781 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	2782 {
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 *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	2784 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	2785 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	2786 *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	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
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2790 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	2791 {
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 *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	2793 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	2794 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	2795 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	2796 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2797 putchar(' ');
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2798 len++;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2799 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2800 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	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
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2803 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	2804 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2805 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	2806 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	2807 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	2808 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	2809 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	2810 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	2811 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2812 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	2813 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	2814 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2815 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	2816 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	2817 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	2818 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	2819 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	2820 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	2821 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	2822 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	2823 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	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 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2828 } else {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2829 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	2830 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	2831 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	2832 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	2833 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2834 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	2835 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2836
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2837 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	2838 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2840 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	2841 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	2842 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	2843 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2844 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	2845 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	2846 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	2847 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2848 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2849 bp_def tmp = this_bp;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2850 if (tmp->type == BP_TYPE_CPU) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2851 remove_breakpoint(root->cpu_context, tmp->address);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2852 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2853 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2854 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2855 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	2856 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2857 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2858 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2859 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2860 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2861 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2862 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2863 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2864
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2865 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	2866 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2868 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	2869 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	2870 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	2871 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2872 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	2873 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	2874 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	2875 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2876 new_bp->mask = 0xFFFFFF;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2877 new_bp->index = root->bp_index++;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2878 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	2879 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	2880 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	2881 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2882 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2883
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2884 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	2885 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2886 value &= 0xFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2887 if (context->regs[reg] == value) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2888 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2889 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2890 genesis_context gen = (genesis_context )context->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2891 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	2892 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	2893 int debugging = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2894 if (*this_bp) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2895 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	2896 debug_val condres;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2897 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	2898 if (!condres.v.u32) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2899 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2900 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2901 } else {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2902 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	2903 free_expr((*this_bp)->condition);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2904 (*this_bp)->condition = NULL;
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 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2907 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	2908 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2909 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	2910 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2911 if (debugging) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2912 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	2913 gen->header.enter_debugger = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2914 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	2915 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	2916 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2917 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	2918 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	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
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2924 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	2925 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2926 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	2927 new_bp->next = root->breakpoints;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2928 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	2929 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	2930 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	2931 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	2932 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 (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	2934 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	2935 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	2936 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	2937 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	2939 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	2940 }
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2941 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2942 new_bp->index = root->bp_index++;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2943 new_bp->type = BP_TYPE_VDPREG;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2944 root->breakpoints = new_bp;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2945 m68k_context *m68k = root->cpu_context;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2946 genesis_context *gen = m68k->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2947 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	2948 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	2949 return 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2950 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	2951
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2952 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	2953 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2955 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	2956 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	2957 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	2958 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2959 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	2960 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2961 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2962
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2963 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	2964 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2965 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2966 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2967 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2968 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2969 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	2970 } 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	2971 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	2972 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2973 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	2974 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2975 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	2976 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	2977 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2978 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2979 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	2980 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	2981 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2982 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2983 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2984 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	2985 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	2986 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2987 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2988 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	2989 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2990 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2991 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	2992 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2993 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2994
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2995 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	2996 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2997 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2998 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2999 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3000 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3001 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	3002 } 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	3003 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	3004 } 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	3005 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	3006 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	3007 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3008 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3009 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3010 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3011 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	3012 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3013 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3014 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	3015 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3016 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3017 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3018 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3019 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3020 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3021 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	3022 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3023 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3024 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3025 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	3026 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3027 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3028 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	3029 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3030 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3031
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3032 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	3033 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3034 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3035 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3036 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3037 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3038 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	3039 } 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	3040 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	3041 } 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	3042 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	3043 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3044 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	3045 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	3046 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3047 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3048 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	3049 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	3050 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3051 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3052 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3053 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	3054 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	3055 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3056 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3057 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	3058 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3059 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3060 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	3061 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3062 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3063
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3064 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	3065 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3066 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3067 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3068 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3069 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3070 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	3071 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	3072 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3073 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3074 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3075 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3076 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3077 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	3078 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3079 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	3080 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3081 //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	3082 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3083 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3084 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3085 //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	3086 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3087 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3088 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3089
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3090 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	3091 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3092 m68k_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3093 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3094 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	3095 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	3096 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	3097 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	3098 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3099 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3100 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3101 m68kinst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3102 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3103 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3104 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3105 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	3106 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3107 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3108 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3109 }
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	3110
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3111 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3112 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3113 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3114 } while(!m68k_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3115 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3116 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3117
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3118 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	3119 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3120 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3121 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3122 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3123 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3124 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3125
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3126 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	3127 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3128 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3129 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3130 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3131 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3132 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3133
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3134 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	3135 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3136 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3137 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	3138 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	3139 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	3140 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3141 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	3142 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	3143 }
2173 894c7873a2b1 Consume all expressions in debugger print command Michael Pavone <pavone@retrodev.com> parents: 2172 diff changeset	3144 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3145 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3146 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3147
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3148 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	3149 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3150 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3151 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3152 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3153 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3154 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3155
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3156 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	3157 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3158 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3159 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3160 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3161 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3162 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3163 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3164 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3165 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3166 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	3167 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3168 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	3169 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3170 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	3171 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3172 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3173 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	3174 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3175 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3176 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	3177 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3178 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3179 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3180 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3181 return 0;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3184
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3185 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	3186 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3187 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3188 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3189 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3190 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3191 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3192 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3193 segacd_context *cd = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3194
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3195 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	3196 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3197 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	3198 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3199 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	3200 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3201 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3202 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	3203 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3204 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3205 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	3206 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3207 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3208 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3209 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3210 return 0;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3213
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3214 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	3215 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3216 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3217 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3218 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3219 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3220 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3221 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3222 genesis_context *gen = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3223
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3224 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	3225 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3226 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	3227 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3228 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	3229 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3230 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3231 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	3232 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3233 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3234 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	3235 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3236 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3237 } else {
2184 408fb8a7e990 Implement argumentless variant of z80 debugger command Michael Pavone <pavone@retrodev.com> parents: 2183 diff changeset	3238 gen->enter_z80_debugger = 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3239 return 0;
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3243 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3244 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3245 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3246 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3247 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3248 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3249 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3250 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3251 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3252 .max_args = 0,
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3255 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3256 "help", "?", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3257 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3258 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3259 .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	3260 .impl = cmd_help,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3261 .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	3262 .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	3263 .raw_args = 1
2178 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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3266 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3267 "continue", "c", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3268 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3269 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3270 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3271 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3272 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3273 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3276 .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	3277 "print", "p", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3278 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3279 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3280 .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	3281 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3282 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3283 .max_args = -1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3286 .names = (const char *[]){
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3287 "printf", NULL
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3288 },
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3289 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3290 .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	3291 .impl = cmd_printf,
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3292 .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	3293 .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	3294 .raw_args = 1
2187 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 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3297 .names = (const char *[]){
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3298 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3299 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3300 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3301 .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	3302 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3303 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3304 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3305 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3306 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3307 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3308 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3309 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3310 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3311 .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	3312 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3313 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3314 .max_args = -1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3317 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3318 "deletedisplay", "dd", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3319 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3320 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3321 .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	3322 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3323 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3324 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3327 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3328 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3329 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3330 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3331 .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	3332 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3333 .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	3334 .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	3335 .has_block = 1
2178 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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3338 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3339 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3340 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3341 .usage = "set MEM\|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3342 .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	3343 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3344 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3345 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3346 .skip_eval = 1
2179 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 {
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3349 .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	3350 "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	3351 },
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 .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	3353 .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	3354 .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	3355 .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	3356 .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	3357 .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	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 {
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	3360 .names = (const char *[]){
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3361 "array", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3362 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3363 .usage = "array NAME [VALUE...]",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3364 .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	3365 .impl = cmd_array,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3366 .min_args = 1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3367 .max_args = -1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3368 .skip_eval = 1
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 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3371 .names = (const char *[]){
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3372 "append", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3373 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3374 .usage = "append NAME VALUE",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3375 .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	3376 .impl = cmd_append,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3377 .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	3378 .max_args = 2
2359 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 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3381 .names = (const char *[]){
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3382 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3383 },
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3384 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3385 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3386 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3387 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3388 .max_args = 1
2181 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 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3391 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3392 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3393 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3394 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3395 .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	3396 .impl = cmd_bindup,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3397 .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	3398 .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	3399 .raw_args = 1
2181 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 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3402 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3403 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3404 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3405 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3406 .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	3407 .impl = cmd_binddown,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3408 .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	3409 .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	3410 .raw_args = 1
2182 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 {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3413 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3414 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3415 },
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3416 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3417 .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	3418 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3419 .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	3420 .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	3421 .skip_eval = 1
2190 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 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3424 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3425 "if", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3426 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3427 .usage = "if CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3428 .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	3429 .impl = cmd_if,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3430 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3431 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3432 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3433 .accepts_else = 1
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 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3436 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3437 "while", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3438 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3439 .usage = "while CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3440 .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	3441 .impl = cmd_while,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3442 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3443 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3444 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3445 .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	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 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3448 .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	3449 "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	3450 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3451 .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	3452 .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	3453 .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	3454 .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	3455 .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	3456 .raw_args = 1
2178 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 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3459 #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	3460
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3461 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3462 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3463 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3464 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3465 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3466 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3467 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3468 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3469 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3470 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3473 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3474 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3475 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3476 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3477 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3478 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3479 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3480 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3483 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3484 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3485 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3486 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3487 .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	3488 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3489 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3490 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3493 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3494 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3495 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3496 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3497 .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	3498 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3499 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3500 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3503 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3504 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3505 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3506 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3507 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3508 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3509 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3510 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3513 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3514 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3515 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3516 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3517 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3518 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3519 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3520 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3523 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3524 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3525 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3526 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3527 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3528 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3529 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3530 .max_args = 1
2216 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 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3533 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3534 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3535 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3536 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3537 .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	3538 .impl = cmd_disassemble_m68k,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3539 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3540 .max_args = 1
2112 3abb64bd0da6 Add support for printing strings in 68K debugger Michael Pavone <pavone@retrodev.com> parents: 2107 diff changeset	3541 }
2178 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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3544 #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	3545
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3546 command_def genesis_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3547 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3548 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3549 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3550 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3551 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3552 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3553 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3554 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3555 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3558 .names = (const char *[]){
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3559 "vdpregs", "vr", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3560 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3561 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3562 .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	3563 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3564 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3565 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3566 },
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3567 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3568 .names = (const char *[]){
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3569 "vdpregbreak", "vregbreak", "vrb", NULL
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3570 },
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3571 .usage = "vdpregbreak [REGISTER [MASK]]",
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3572 .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	3573 .impl = cmd_vdp_reg_break,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3574 .min_args = 0,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3575 .max_args = 2
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3576 },
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3577 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3578 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3579 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3580 "z80", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3581 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3582 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3583 .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	3584 .impl = cmd_gen_z80,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3585 .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	3586 .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	3587 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3588 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3589 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3590 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3591 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3592 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3593 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3594 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3595 .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	3596 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3597 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3598 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3601 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3602 "ymtimer", "yt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3603 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3604 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3605 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3606 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3607 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3608 .max_args = 0
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3612 #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	3613
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3614 command_def scd_main_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3615 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3616 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3617 "subcpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3618 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3619 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3620 .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	3621 .impl = cmd_sub,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3622 .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	3623 .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	3624 .raw_args = 1
2178 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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3628 #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	3629
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3630 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3631 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3632 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3633 "maincpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3634 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3635 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3636 .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	3637 .impl = cmd_main,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3638 .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	3639 .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	3640 .raw_args = 1
2178 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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3644 #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	3645
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3646 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3647
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3648 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	3649 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	3651 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	3652 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	3653 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	3654 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3655 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	3656 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	3657 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	3658 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3659 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3660 bp_def tmp = this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3661 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	3662 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3663 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3664 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	3665 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3666 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3667 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3668 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3669 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3670 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3671 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3672 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3673
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3674 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	3675 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	3677 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	3678 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	3679 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	3680 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3681 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	3682 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	3683 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	3684 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3685 new_bp->mask = 0xFFFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3686 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	3687 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3688 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	3689 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	3690 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3691 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3692
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3693 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	3694 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	3696 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	3697 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	3698 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	3699 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3700 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	3701 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3702 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3703
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3704 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	3705 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3706 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3707 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3708 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3709 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3710 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	3711 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3712 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3713 } 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	3714 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3715 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	3716 } 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	3717 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	3718 } 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	3719 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	3720 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3721 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3722 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3723 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3724 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3725 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	3726 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3727 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3728 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	3729 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3730 after \|= *sp << 8;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3734 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	3735 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3736 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3737
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3738 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	3739 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3740 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3741 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3742 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3743
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3744 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	3745 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3746 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3747 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3748 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3749 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3750 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3751 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3752 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3753 } 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	3754 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3755 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	3756 } 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	3757 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	3758 } 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	3759 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	3760 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3761 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3762 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3763 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3764 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3765 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	3766 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3767 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3768 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	3769 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3770 after \|= *sp << 8;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3774 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	3775 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3776 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3777
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3778 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	3779 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3780 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3781 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3782 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3783 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3784 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3785 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	3786 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3787 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3788 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	3789 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3790 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3791 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3792 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3793 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3794 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	3795 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3796 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3797 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	3798 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3799 //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	3800 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3801 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3802 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3803 //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	3804 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3805 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3806 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3807
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3808 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	3809 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3810 z80_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3811 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3812 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	3813 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	3814 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	3815 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	3816 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3817 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3818 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3819 z80inst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3820 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3821 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3822 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3823 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	3824 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3825 printf("%s:\n", def->labels[i]);
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 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3828 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	3829 uint8_t *after = z80_decode(pc, &inst);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3830 z80_disasm(&inst, disasm_buf, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3831 address += after - pc;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3832 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3833 } while(!z80_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3834 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3835 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3836
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3837 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	3838 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3839 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	3840 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	3841 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3842 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3843 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3844 genesis_context gen = (genesis_context )current_system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3845
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3846 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	3847 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	3848 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	3849 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	3850 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	3851 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3852 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3853 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	3854 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3855 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3856 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	3857 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	3858 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3859 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3860 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	3861 return 0;
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 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3864
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3865 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	3866 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3867 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	3868 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	3869 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	3870 return 1;
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
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3873 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	3874 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3875 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	3876 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	3877 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	3878 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3879 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3880
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3881 command_def z80_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3882 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3883 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3884 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3885 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3886 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3887 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3888 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3889 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3890 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3893 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3894 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3895 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3896 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3897 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3898 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3899 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3900 .max_args = 1
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3903 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3904 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3905 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3906 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3907 .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	3908 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3909 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3910 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3913 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3914 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3915 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3916 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3917 .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	3918 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3919 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3920 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3923 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3924 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3925 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3926 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3927 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3928 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3929 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3930 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3933 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3934 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3935 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3936 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3937 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3938 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3939 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3940 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3943 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3944 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3945 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3946 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3947 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3948 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3949 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3950 .max_args = 1
2216 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 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3953 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3954 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3955 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3956 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3957 .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	3958 .impl = cmd_disassemble_z80,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3959 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3960 .max_args = 1
2178 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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3964 #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	3965
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3966 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	3967 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3968 .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	3969 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3970 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3971 .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	3972 .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	3973 .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	3974 .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	3975 .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	3976 .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	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
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	3980 #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	3981
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3982 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	3983 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3984 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3985 "vdpsprites", "vs", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3986 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3987 .usage = "vdpsprites",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3988 .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	3989 .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	3990 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3991 .max_args = 0
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 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3994 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3995 "vdpsregs", "vr", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3996 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3997 .usage = "vdpregs",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	3998 .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	3999 .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	4000 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4001 .max_args = 0
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
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4005 #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	4006
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4007 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4008
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4009 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	4010 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4011 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	4012 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4013 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	4014 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4015 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	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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4019
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4020 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	4021 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4022 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	4023 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	4024 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	4025 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4026 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	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 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4029
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4031 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4033 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	4034 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4035
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4036 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	4037 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4038 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4039 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4040 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	4041 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	4042 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4043 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	4044 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	4045 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	4046 debug_var *var;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4047 switch (current_system->type)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4048 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4049 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4050 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4051 //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	4052 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	4053 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	4054 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	4055 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	4056 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	4057 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	4058 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	4059 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	4060 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	4061 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	4062 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	4063 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	4064 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	4065 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	4066 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	4067 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	4068 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4069 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4070 } 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	4071 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	4072 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	4073 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	4074 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	4075 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4076 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	4077 break;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4078 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4079 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	4080 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4081 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	4082 }
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	4083
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	4084 #ifndef NO_Z80
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4085
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4086 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	4087 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4088 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4089 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4090 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	4091 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4092 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	4093 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4094 return 1;
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
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4097 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	4098 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4099 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4100 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	4101 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4102 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	4103 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4104 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4105 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4106
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4108 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4110 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4114 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4116 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	4117 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	4118 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	4119 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	4120 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4126 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4128 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4132 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4134 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	4135 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	4136 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	4137 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	4138 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4143 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4145 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	4146 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	4147 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	4148 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	4149 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	4150 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	4151 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	4152 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	4153 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4157 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4159 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	4160 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	4161 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	4162 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	4163 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	4164 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	4165 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	4166 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	4167 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4170 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	4171 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4173 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	4174 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	4175 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	4176 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	4177 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	4179 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	4180 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	4181 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	4182 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	4183 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4187 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4189 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	4190 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	4191 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	4192 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	4193 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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_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	4195 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	4196 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	4197 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	4198 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	4199 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4203 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4205 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	4206 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	4207 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	4208 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	4209 } 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	4210 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	4211 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4216 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4218 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	4219 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	4220 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	4221 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	4222 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4224 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	4225 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	4226 } 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	4227 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	4228 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4233 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4235 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	4236 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	4237 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	4238 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	4239 } 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	4240 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	4241 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4246 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4248 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	4249 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	4250 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	4251 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	4252 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4254 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	4255 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	4256 } 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	4257 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	4258 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	4259 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4260 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4261
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4263 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4265 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4268 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	4269 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4271 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	4272 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	4273 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	4274 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	4275 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4280 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4282 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4286 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4288 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	4289 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	4290 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	4291 return;
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4292 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4297 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4299 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4303 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4305 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4309 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4311 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4315 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4317 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4321 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4323 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4327 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4329 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	4330 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4331
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4332 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	4333 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4335 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	4336 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	4338 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	4339 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	4340 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	4341 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	4342 } 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	4343 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	4344 var->set = z80_sp_set;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4345 } 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	4346 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	4347 var->set = z80_regpair_set;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4348 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4350 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	4351 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	4352 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	4353 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	4354 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	4355 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4356 d = toupper(c);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4357 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4359 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	4360
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4362 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	4363 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	4364 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	4365 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	4366 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	4367 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	4368 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	4369 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	4370 } 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	4371 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	4372 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	4373 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4375 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	4376 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	4377 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	4378 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4379 d = toupper(c);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4380 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4381 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	4382 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4383 free(name);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4384 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	4386 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	4387 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	4388 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	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 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	4391 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	4392 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	4393 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	4394 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	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 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	4397 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	4398 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	4399 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	4400 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	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 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	4403 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	4404 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	4405 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	4406 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	4407 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	4408 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	4409 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	4410 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	4411 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	4412 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	4413 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	4414 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	4415 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	4416 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	4417 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	4418 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	4419 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	4420 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	4421 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	4422 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4423
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4424 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	4425 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4426 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4427 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4428 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	4429 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	4430 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	4431 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	4432 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	4433 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	4434 //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	4435 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	4436 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4437 case SYSTEM_GENESIS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4438 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	4439 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	4440 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	4441 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	4442 //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	4443 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4444 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	4445 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	4446 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	4447 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	4448 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	4449 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	4450 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	4451 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	4452 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	4453 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	4454 //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	4455 //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	4456 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4457 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4458 root->write_mem = write_z80;
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4459 root->disasm = create_z80_disasm();
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4460 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4461 return root;
524 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
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4464 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	4465 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4466 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4467 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4468 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	4469 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	4470 init_terminal();
2180 b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor Michael Pavone <pavone@retrodev.com> parents: 2179 diff changeset	4471 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	4472 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	4473 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	4474 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4475 root->address = address;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4476 //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	4477 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	4478 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4479 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	4480 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4481 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	4482 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4483 return context;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4484 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4485 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4486 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	4487 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4488 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4489 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4490 }
2208 3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4491 int debugging = 1;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4492 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	4493 {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4494 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	4495 }
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4496 if (debugging) {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4497 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	4498 } else {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4499 return context;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4500 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4501 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4502 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4503 }
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	4504 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	4505 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode Michael Pavone <pavone@retrodev.com> parents: 1111 diff changeset	4506 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	4507 }
2188 e17d99c96c89 Make blocks an 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 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	4509 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	4510 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	4511 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	4512 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	4513 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	4514 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4515 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4516 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4517 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	4518 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	4519 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4520 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4521
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4522 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4523 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	4524 debugger_repl(root);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4525 return context;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4526 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4527
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4528 #endif
a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4529
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	4530 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	4531 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4532 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4533 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4534 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	4535
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	4536 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	4537
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	4538 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	4539 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4540 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4541 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4542 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4543 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	4544 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	4545 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	4546 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4547 //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	4548 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	4549 if (address == root->branch_t) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4550 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	4551 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	4552 remove_breakpoint(context, root->branch_f);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4553 }
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	4554 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	4555 } else if(address == root->branch_f) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4556 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	4557 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	4558 remove_breakpoint(context, root->branch_t);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4559 }
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	4560 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	4561 }
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	4562
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4563 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	4564 int debugging = 1;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4565 //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	4566 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	4567 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4568 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	4569 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4570 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	4571 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4572 return;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4573 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4574 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4575 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	4576 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4577 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4578 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4579 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4580 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	4581 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4582 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	4583 }
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 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	4585 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	4586 } 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	4587 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	4588 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4589 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4590 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4591 }
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4592 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	4593 root->after = after;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4594 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	4595 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	4596 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	4597 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4598 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4599 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4600 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	4601 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	4602 }
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	4603 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4604 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	4605 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	4606 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	4607 return;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4608 }

Mercurial > repos > blastem

annotate debug.c @ 2366:1e36d8a2633c