repos/blastem: debug.c annotate

annotate debug.c @ 2380:1b21290358a8

Fix regression in debugger for Mega CD

author	Michael Pavone <pavone@retrodev.com>
date	Mon, 20 Nov 2023 19:53:00 -0800
parents	1fe5afe263f3
children	9f178feb3cb0

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
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	55 static debug_val new_user_func(command_block block, char *args, int num_args)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	56 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	57 debug_func *f = alloc_func();
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	58 f->impl.block = *block;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	59 f->arg_names = args;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	60 f->max_args = f->min_args = num_args;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	61 f->is_native = 0;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	62 return (debug_val) {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	63 .v = {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	64 .u32 = f - funcs
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	65 },
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	66 .type = DBG_VAL_FUNC
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	67 };
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	68 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	69
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	70 debug_val user_var_get(debug_var *var)
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	71 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	72 return var->val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	73 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	74
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	75 void user_var_set(debug_var *var, debug_val val)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	76 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	77 var->val = val;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	78 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	79
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	80 static void new_user_variable(debug_root root, const char name, debug_val val)
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	81 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	82 debug_var *var = calloc(1, sizeof(debug_var));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	83 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	84 var->set = user_var_set;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	85 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	86 root->variables = tern_insert_ptr(root->variables, name, var);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	87 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	88
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	89 static void new_readonly_variable(debug_root root, const char name, debug_val val)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	90 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	91 debug_var *var = calloc(1, sizeof(debug_var));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	92 var->get = user_var_get;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	93 var->set = NULL;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	94 var->val = val;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	95 root->variables = tern_insert_ptr(root->variables, name, var);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	96 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	97
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	98 static debug_array *arrays;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	99 static uint32_t num_arrays, array_storage;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	100 static debug_array *alloc_array(void)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	101 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	102 if (num_arrays == array_storage) {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	103 array_storage = array_storage ? array_storage * 2 : 4;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	104 arrays = realloc(arrays, sizeof(debug_array) * array_storage);
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	105 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	106 return arrays + num_arrays++;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	107 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	108
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	109 static debug_val new_fixed_array(void *base, debug_array_get get, debug_array_set set, uint32_t size)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	110 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	111 debug_array *array = alloc_array();
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	112 array->get = get;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	113 array->set = set;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	114 array->append = NULL;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	115 array->base = base;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	116 array->size = array->storage = size;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	117 debug_val ret;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	118 ret.type = DBG_VAL_ARRAY;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	119 ret.v.u32 = array - arrays;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	120 return ret;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	121 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	122
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	123 static debug_val user_array_get(debug_array *array, uint32_t index)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	124 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	125 debug_val *data = array->base;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	126 return data[index];
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	127 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	128
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	129 static void user_array_set(debug_array *array, uint32_t index, debug_val value)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	130 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	131 debug_val *data = array->base;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	132 data[index] = value;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	133 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	134
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	135 static void user_array_append(debug_array *array, debug_val value)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	136 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	137 if (array->size == array->storage) {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	138 array->storage *= 2;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	139 array->base = realloc(array->base, sizeof(debug_val) * array->storage);
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	140 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	141 debug_val *data = array->base;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	142 data[array->size++] = value;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	143 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	144
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	145 static debug_val new_user_array(uint32_t size)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	146 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	147 debug_array *array = alloc_array();
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	148 array->get = user_array_get;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	149 array->set = user_array_set;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	150 array->append = user_array_append;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	151 array->size = size;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	152 array->storage = size ? size : 4;
2367 48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	153 array->base = calloc(size, sizeof(debug_val));
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	154 debug_val ret;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	155 ret.type = DBG_VAL_ARRAY;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	156 ret.v.u32 = array - arrays;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	157 return ret;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	158 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	159
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	160 debug_array *get_array(debug_val val)
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	161 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	162 if (val.type != DBG_VAL_ARRAY) {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	163 return NULL;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	164 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	165 return arrays + val.v.u32;
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	166 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	167
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	168 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	169 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	170 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	171 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	172 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	173 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	174 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	175 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	176 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	177 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	178 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	179 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	180
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	181 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	182 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	183 if (val.type == DBG_VAL_U32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	184 *out = val.v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	185 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	186 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	187 if (val.type == DBG_VAL_F32) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	188 *out = val.v.f32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	189 return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	190 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	191 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	192 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	194 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	195 {
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	196 switch(val.type)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	197 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	198 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	199 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	200 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	201 default: return 1;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	202 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	203 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	204
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	205 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	206 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	207 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	208 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	209 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	210 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	211 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	212
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	213 static debug_val debug_float(float f)
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	214 {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	215 return (debug_val) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	216 .type = DBG_VAL_F32,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	217 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	218 .f32 = f
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	219 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	220 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	221 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	222
2367 48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	223 static debug_val debug_sin(debug_val *args, int num_args)
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	224 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	225 float f;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	226 if (!debug_cast_float(args[0], &f)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	227 return debug_float(0.0f);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	228 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	229 return debug_float(sinf(f));
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
2367 48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	232 static debug_val debug_cos(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	233 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	234 float f;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	235 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	236 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	237 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	238 return debug_float(cosf(f));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	239 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	240
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	241 static debug_val debug_tan(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	242 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	243 float f;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	244 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	245 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	246 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	247 return debug_float(tanf(f));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	248 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	249
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	250 static debug_val debug_asin(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	251 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	252 float f;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	253 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	254 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	255 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	256 return debug_float(asinf(f));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	257 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	258
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	259 static debug_val debug_acos(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	260 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	261 float f;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	262 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	263 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	264 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	265 return debug_float(acosf(f));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	266 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	267
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	268 static debug_val debug_atan(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	269 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	270 float f;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	271 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	272 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	273 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	274 return debug_float(atanf(f));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	275 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	276
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	277 static debug_val debug_atan2(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	278 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	279 float f, f2;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	280 if (!debug_cast_float(args[0], &f)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	281 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	282 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	283 if (!debug_cast_float(args[1], &f2)) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	284 return debug_float(0.0f);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	285 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	286 return debug_float(atan2f(f, f2));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	287 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	288
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	289 static debug_val array_pop(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	290 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	291 debug_array array = get_array(args);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	292 if (!array) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	293 return debug_int(0);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	294 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	295 debug_val ret = array->get(array, array->size - 1);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	296 if (array->append) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	297 array->size--;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	298 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	299 return ret;
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	300 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	301
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	302 static debug_val debug_size(debug_val *args, int num_args)
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	303 {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	304 debug_array array = get_array(args);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	305 if (!array) {
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	306 //TODO: string support
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	307 return debug_int(0);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	308 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	309 return debug_int(array->size);
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	310 }
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	311
2380 1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	312 static debug_root **roots;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	313 static uint32_t num_roots, root_storage;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	314
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	315 debug_root find_root(void cpu)
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	316 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	317 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	318 {
2380 1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	319 if (roots[i]->cpu_context == cpu) {
1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	320 return roots[i];
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	321 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	322 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	323 if (num_roots == root_storage) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	324 root_storage = root_storage ? root_storage * 2 : 5;
2380 1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	325 roots = realloc(roots, root_storage * sizeof(debug_root*));
1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	326 }
1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	327 debug_root *root = calloc(1, sizeof(debug_root));
1b21290358a8 Fix regression in debugger for Mega CD Michael Pavone <pavone@retrodev.com> parents: 2371 diff changeset	328 roots[num_roots++] = root;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	329 root->cpu_context = cpu;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	330 new_readonly_variable(root, "sin", new_native_func(debug_sin, 1, 1));
2367 48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	331 new_readonly_variable(root, "cos", new_native_func(debug_cos, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	332 new_readonly_variable(root, "tan", new_native_func(debug_tan, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	333 new_readonly_variable(root, "asin", new_native_func(debug_asin, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	334 new_readonly_variable(root, "acos", new_native_func(debug_acos, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	335 new_readonly_variable(root, "atan", new_native_func(debug_atan, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	336 new_readonly_variable(root, "atan2", new_native_func(debug_atan2, 2, 2));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	337 new_readonly_variable(root, "pop", new_native_func(array_pop, 1, 1));
48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	338 new_readonly_variable(root, "size", new_native_func(debug_size, 1, 1));
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	339 return root;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	340 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	341
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	342 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	343 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	344 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	345 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	346 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	347 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	348 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	349 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	350 return cur;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	351 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	352
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	353 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	354 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	355 while (*cur) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	356 if ((*cur)->index == index) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	357 break;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	358 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	359 cur = &((*cur)->next);
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	360 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	361 return cur;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	362 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	363
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	364 static const char *token_type_names[] = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	365 "TOKEN_NONE",
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	366 "TOKEN_INT",
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	367 "TOKEN_DECIMAL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	368 "TOKEN_NAME",
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	369 "TOKEN_ARRAY",
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	370 "TOKEN_FUNCALL",
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	371 "TOKEN_OPER",
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	372 "TOKEN_SIZE",
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	373 "TOKEN_LBRACKET",
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	374 "TOKEN_RBRACKET",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	375 "TOKEN_LPAREN",
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	376 "TOKEN_RPAREN"
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	377 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	378
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	379 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	380 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	381 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	382 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	383 ++start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	384 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	385 if (!start \|\| start == '\n' \|\| *start == '\r') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	386 return (token){
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	387 .type = TOKEN_NONE
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	388 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	389 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	390 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	391 if (start == '$' \|\| (start == '0' && start[1] == 'x')) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	392 return (token) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	393 .type = TOKEN_INT,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	394 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	395 .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	396 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	397 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	398 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	399 if (isdigit(*start)) {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	400 uint32_t ipart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	401 if (**end == '.') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	402 start = *end + 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	403 uint32_t fpart = strtol(start, end, 10);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	404 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	405 if (fpart) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	406 float divisor = powf(10.0f, *end - start);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	407 fval = ipart + fpart / divisor;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	408 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	409 fval = ipart;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	410 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	411 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	412 .type = TOKEN_DECIMAL,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	413 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	414 .f = fval
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	415 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	416 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	417 } else {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	418 return (token) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	419 .type = TOKEN_INT,
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	420 .v = {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	421 .num = ipart
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	422 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	423 };
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	424 }
2169 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 switch (*start)
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 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	429 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	430 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	431 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	432 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	433 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	434 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	435 case '~':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	436 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	437 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	438 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	439 case '<':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	440 if ((start == '!' \|\| start == '>' \|\| *start == '<') && start[1] == '=') {
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	441 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	442 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	443 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	444 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	445 .op = {*start, start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	446 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	447 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	448 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	449 *end = start + 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	450 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	451 .type = TOKEN_OPER,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	452 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	453 .op = {*start, 0}
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 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	456 case '.':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	457 *end = start + 2;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	458 return (token) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	459 .type = TOKEN_SIZE,
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	460 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	461 .op = {start[1], 0}
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	462 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	463 };
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	464 case '[':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	465 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	466 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	467 .type = TOKEN_LBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	468 };
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	469 case ']':
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	470 *end = start + 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	471 return (token) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	472 .type = TOKEN_RBRACKET
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	473 };
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	474 case '(':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	475 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	476 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	477 .type = TOKEN_LPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	478 };
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	479 case ')':
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	480 *end = start + 1;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	481 return (token) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	482 .type = TOKEN_RPAREN
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	483 };
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	484 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	485 *end = start + 1;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	486 token_type type = TOKEN_NAME;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	487 while (end && !isspace(end))
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	488 {
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	489 uint8_t done = 0;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	490 switch (**end)
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	491 {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	492 case '[':
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	493 type = TOKEN_ARRAY;
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	494 done = 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	495 break;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	496 case '(':
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	497 type = TOKEN_FUNCALL;
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	498 case '+':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	499 case '-':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	500 case '*':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	501 case '/':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	502 case '&':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	503 case '\|':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	504 case '^':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	505 case '~':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	506 case '=':
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	507 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	508 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	509 case '<':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	510 case '.':
2357 344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	511 case ']':
344c6a3fe8a8 Fix annoying bug in debugger tokenizer Michael Pavone <pavone@retrodev.com> parents: 2302 diff changeset	512 case ')':
2172 a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	513 done = 1;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	514 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	515 }
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	516 if (done) {
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	517 break;
a00773a336d8 Fix bug in debugger lexer Michael Pavone <pavone@retrodev.com> parents: 2171 diff changeset	518 }
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	519
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	520 ++*end;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	521 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	522 char name = malloc(end - start + 1);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	523 memcpy(name, start, *end - start);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	524 name[*end-start] = 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	525 return (token) {
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	526 .type = type,
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	527 .v = {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	528 .str = name
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	529 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	530 };
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	531 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	532
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	533 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	534 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	535 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	536 free_expr(e->left);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	537 if (e->type == EXPR_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	538 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	539 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	540 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	541 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	542 free(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	543 } else {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	544 free_expr(e->right);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	545 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	546 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	547 free(e->op.v.str);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	548 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	549 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	550
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	551 static void free_expr(expr *e)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	552 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	553 if (!e) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	554 return;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	555 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	556 free_expr_int(e);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	557 free(e);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	558 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	559
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	560 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	561 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	562
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	563 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	564 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	565 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	566 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	567 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	568 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	569 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	570 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	571 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	572 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	573 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	574 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	575 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	576 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	577 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	578 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	579 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	580 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	581 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	582 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	583 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	584 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	585 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	586 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	587 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	588 //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	589 //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	590 //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	591 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	592 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	593 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	594 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	595
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	596 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	597 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	598 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	599 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	600 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	601 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	602 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	603 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	604 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	605 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	606 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	607 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	608 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	609 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	610 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	611 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	612 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	613 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	614 ret->type = EXPR_UNARY;
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 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	617 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	618 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	619 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	620 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	621 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	622 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	623 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	624 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	625 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	626 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	627 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	628 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	629 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	630 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	631 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	632
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	633 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	634 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	635 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	636 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	637 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	638 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	639 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	640 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	641 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	642 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	643 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	644 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	645 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	646 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	647 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	648 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	649 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	650 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	651 return ret;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	652 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	653 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	654 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	655 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	656 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	657 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	658 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	659 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	660 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	661 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	662 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	663 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	664 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	665 return ret;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	666 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	667 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	668 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	669 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	670 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	671 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	672 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	673 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	674 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	675 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	676 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	677 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	678 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	679 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	680 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	681 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	682 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	683 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	684 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	685 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	686 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	687 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	688 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	689 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	690 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	691 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	692 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	693 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	694 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	695 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	696 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	697 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	698 return ret;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	699 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	700 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	701 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	702 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	703 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	704 token second = parse_token(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	705 if (second.type != TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	706 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	707 ret->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	708 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	709 handle_namespace(ret);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	710 *end = after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	711 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	712 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	713 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	714 ret->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	715 ret->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	716 ret->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	717 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	718 handle_namespace(ret->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	719 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	720 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	721 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	722
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	723 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	724 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	725 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	726 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	727 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	728 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	729 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	730 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	731 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	732 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	733 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	734 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	735 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	736 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	737 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	738 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	739 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	740 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	741 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	742 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	743 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	744 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	745 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	746 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	747 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	748 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	749 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	750 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	751 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	752 bin->right = parse_expression(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	753 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	754 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	755 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	756 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	757 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	758 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	759 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	760
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	761 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	762 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	763 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	764 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	765 if (first.type != TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	766 *end = start;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	767 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	768 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	769 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	770 bin->left = left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	771 bin->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	772 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	773 switch (first.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	774 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	775 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	776 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	777 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	778 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	779 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	780 bin->right = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	781 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	782 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	783 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	784 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	785 return left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	786 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	787 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	788
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	789 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	790 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	791 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	792 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	793 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	794 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	795 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	796 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	797 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	798 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	799 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	800 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	801 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	802 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	803 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	804 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	805 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	806 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	807 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	808 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	809 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	810 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	811 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	812 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	813 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	814 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	815 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	816 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	817 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	818 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	819 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	820 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	821 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	822 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	823 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	824
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	825 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	826 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	827 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	828 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	829 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	830 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	831 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	832 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	833 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	834 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	835 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	836 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	837 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	838 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	839 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	840 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	841 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	842 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	843 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	844 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	845 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	846 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	847 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	848 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	849 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	850 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	851 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	852 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	853 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	854 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	855 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	856 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	857 return maybe_muldiv(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	858 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	859 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	860 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	861 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	862 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	863 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	864 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	865 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	866 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	867 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	868 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	869 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	870 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	871 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	872 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	873 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	874 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	875 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	876 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	877 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	878 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	879 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	880 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	881 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	882 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	883 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	884 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	885 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	886 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	887 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	888 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	889 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	890 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	891 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	892 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	893 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	894 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	895 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	896 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	897 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	898 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	899 expr *ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	900 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	901 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	902 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	903 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	904 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	905 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	906 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	907 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	908 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	909 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	910 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	911 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	912 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	913 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	914 bin->right = parse_scalar(after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	915 return maybe_muldiv(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	916 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	917 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	918 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	919 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	920 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	921 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	922 ret = bin->left;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	923 bin->left = NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	924 free_expr(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	925 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	926 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	927 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	928 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	929 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	930 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	931 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	932 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	933 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	934 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	935 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	936 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	937 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	938 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	939 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	940 return maybe_muldiv(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	941 } else {
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	942 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	943 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	944 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	945 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	946 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	947 return ret;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	948 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	949 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	950
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	951 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	952 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	953 char *after_first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	954 token first = parse_token(start, &after_first);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	955 if (!first.type) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	956 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	957 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	958 if (first.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	959 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	960 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	961 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	962 if (first.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	963 expr *target = parse_scalar(after_first, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	964 if (!target) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	965 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	966 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	967 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	968 expr *ret = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	969 ret->type = EXPR_UNARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	970 ret->op = first;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	971 ret->left = target;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	972 return ret;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	973 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	974 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	975 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	976 ret->type = EXPR_MEM;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	977 if (first.type == TOKEN_ARRAY) {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	978 //current token is the array name
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	979 //consume the bracket token
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	980 parse_token(after_first, &after_first);
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	981 ret->right = calloc(1, sizeof(expr));
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	982 ret->right->type = EXPR_SCALAR;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	983 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	984 handle_namespace(ret->right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	985 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	986
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	987 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	988 if (!ret->left) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	989 fprintf(stderr, "Expression expected after `[`\n");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	990 free(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	991 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	992 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	993 token rbrack = parse_token(*end, end);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	994 if (rbrack.type != TOKEN_RBRACKET) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	995 fprintf(stderr, "Missing closing `]`");
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	996 free_expr(ret);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	997 return NULL;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	998 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	999 char *after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1000 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	1001 if (size.type == TOKEN_SIZE) {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1002 *end = after_size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1003 ret->op = size;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1004 }
2171 4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1005 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1006 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1007 if (first.type == TOKEN_LPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1008 expr *ret = parse_expression(after_first, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1009 if (!ret) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1010 fprintf(stderr, "Expression expected after `(`\n");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1011 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1012 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1013 token rparen = parse_token(*end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1014 if (rparen.type != TOKEN_RPAREN) {
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1015 fprintf(stderr, "Missing closing `)`");
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1016 free_expr(ret);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1017 return NULL;
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1018 }
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1019 return maybe_binary(ret, *end, end);
4b47155965c8 Implement parentheses in debugger parser Michael Pavone <pavone@retrodev.com> parents: 2170 diff changeset	1020 }
2364 c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1021 if (first.type == TOKEN_FUNCALL) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1022 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	1023 ret->type = EXPR_FUNCALL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1024 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	1025 ret->left->type = EXPR_SCALAR;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1026 ret->left->op = first;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1027 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	1028 uint32_t storage = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1029 ret->op.v.num = 0;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1030 //consume LPAREN
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1031 parse_token(after_first, end);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1032 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1033 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	1034 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	1035 {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1036 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	1037 if (!e) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1038 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	1039 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1040 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1041 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1042 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	1043 storage = storage ? storage * 2 : 1;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1044 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	1045 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1046 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	1047 free(e);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1048 after_first = *end;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1049 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	1050 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1051 if (next.type != TOKEN_RPAREN) {
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1052 fprintf(stderr, "Missing ')' after '('\n");
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1053 free_expr(ret);
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1054 return NULL;
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1055 }
c822bb628fc3 Add support for function call expressions in debug parser Michael Pavone <pavone@retrodev.com> parents: 2363 diff changeset	1056 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	1057 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1058 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	1059 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	1060 return NULL;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1061 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1062 char *after_second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1063 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	1064 if (second.type == TOKEN_OPER) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1065 expr *bin = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1066 bin->type = EXPR_BINARY;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1067 bin->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1068 bin->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1069 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	1070 handle_namespace(bin->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1071 bin->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1072 switch (second.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1073 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1074 case '*':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1075 case '/':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1076 case '&':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1077 case '\|':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1078 case '^':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1079 bin->right = parse_scalar(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1080 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1081 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	1082 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1083 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1084 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1085 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1086 case '+':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1087 case '-':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1088 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	1089 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1090 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	1091 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1092 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1093 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1094 return maybe_binary(bin, *end, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1095 case '=':
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1096 case '!':
2191 d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	1097 case '>':
d87a76afbd8a Add '>', '<', '>=' and '<=' operators to debugger expression engine Michael Pavone <pavone@retrodev.com> parents: 2190 diff changeset	1098 case '<':
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1099 bin->right = parse_expression(after_second, end);
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1100 if (!bin->right) {
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1101 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	1102 free_expr(bin);
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1103 return NULL;
935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	1104 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1105 return bin;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1106 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1107 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	1108 free(bin->left);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1109 free(bin);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1110 return NULL;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1111 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1112 } else if (second.type == TOKEN_SIZE) {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1113 expr *value = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1114 value->type = EXPR_SIZE;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1115 value->op = second;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1116 value->left = calloc(1, sizeof(expr));
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1117 value->left->type = EXPR_SCALAR;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1118 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	1119 handle_namespace(value->left);
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1120 return maybe_binary(value, after_second, end);
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1121 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1122 if (second.type == TOKEN_NAME) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1123 free(second.v.str);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1124 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1125 expr *ret = calloc(1, sizeof(expr));
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1126 ret->type = EXPR_SCALAR;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1127 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	1128 handle_namespace(ret);
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1129 *end = after_first;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1130 return ret;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1131 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1132 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1133
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1134 static uint8_t execute_block(debug_root root, command_block block);
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1135 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	1136 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 debug_val right;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1138 debug_val *args;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1139 debug_func *func;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1140 int num_args;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1141 switch(e->type)
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1142 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1143 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	1144 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	1145 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	1146 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	1147 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	1148 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 = 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	1150 return 1;
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1151 } else if (e->op.type == TOKEN_INT) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1152 *out = debug_int(e->op.v.num);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1153 return 1;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1154 } else {
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	1155 *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	1156 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1157 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1158 case EXPR_UNARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1159 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	1160 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1161 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1162 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1163 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1164 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	1165 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	1166 out->v.u32 = !out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1167 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1168 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	1169 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	1170 out->v.u32 = ~out->v.u32;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1171 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1172 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	1173 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	1174 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	1175 } 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	1176 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	1177 } 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	1178 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	1179 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	1180 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1181 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1182 default:
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 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1185 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1186 case EXPR_BINARY:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1187 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	1188 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1189 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1190 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	1191 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	1192 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	1193 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	1194 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	1195 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	1196 } 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	1197 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	1198 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	1199 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 } 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	1201 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	1202 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	1203 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	1204 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	1205 } 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	1206 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	1207 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	1208 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1209 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1212 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	1213 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1214 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	1215 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	1216 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	1217 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	1218 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	1219 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	1220 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	1221 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	1222 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	1223 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	1224 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	1225 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	1226 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	1227 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	1228 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	1229 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	1230 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	1231 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	1232 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	1233 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	1234 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	1235 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	1236 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	1237 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	1238 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	1239 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	1240 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	1241 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	1242 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	1243 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	1244 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	1245 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	1246 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	1247 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	1248 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	1249 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1250 } 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	1251 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	1252 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1253 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	1254 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	1255 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	1256 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	1257 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	1258 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	1259 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	1260 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	1261 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	1262 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	1263 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	1264 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	1265 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	1266 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	1267 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	1268 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	1269 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	1270 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	1271 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	1272 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	1273 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	1274 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	1275 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	1276 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	1277 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	1278 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	1279 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	1280 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	1281 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	1282 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	1283 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1284 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1285 return 1;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1286 case EXPR_SIZE:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1287 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	1288 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1289 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1290 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	1291 switch (e->op.v.op[0])
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1292 {
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1293 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	1294 out->v.u32 &= 0xFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1295 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1296 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	1297 out->v.u32 &= 0xFFFF;
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1298 break;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1299 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1300 return 1;
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1301 case EXPR_MEM:
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1302 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	1303 return 0;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1304 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1305 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	1306 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	1307 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	1308 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	1309 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1310 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	1311 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	1312 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	1313 return 0;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1314 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1315 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	1316 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	1317 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1318 *out = array->get(array, out->v.u32);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1319 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1320 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1321 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	1322 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	1323 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	1324 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	1325 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	1326 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	1327 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1328 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	1329 case EXPR_FUNCALL:
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1330 if (!eval_expr(root, e->left, out)) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1331 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1332 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1333 if (out->type != DBG_VAL_FUNC) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1334 fprintf(stderr, "Funcall expression requires function");
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1335 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1336 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1337 func = funcs + out->v.u32;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1338 num_args = e->op.v.num;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1339 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	1340 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	1341 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1342 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1343 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	1344 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	1345 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1346 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1347 args = calloc(num_args, sizeof(debug_val));
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1348 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	1349 {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1350 if (!eval_expr(root, e->right + i, args + i)) {
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1351 free(args);
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1352 return 0;
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1353 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1354 }
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1355 if (func->is_native) {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1356 *out = func->impl.native(args, num_args);
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1357 free(args);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1358 return 1;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1359 } else {
8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1360 //TODO: Implement me
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1361 debug_root *func_root = calloc(1, sizeof(debug_root));
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1362 for (int i = 0; i < num_args; i++)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1363 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1364 new_user_variable(func_root, func->arg_names[i], args[i]);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1365 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1366 free(args);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1367 func_root->other_roots = tern_insert_ptr(func_root->other_roots, "parent", root);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1368 execute_block(func_root, &func->impl.block);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1369 *out = func_root->retval;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1370 //FIXME: properly free root
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1371 tern_free(func_root->variables);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1372 tern_free(func_root->other_roots);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1373 free(func_root);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	1374 return 1;
2365 8c060849a503 Basic function call support in debug language Michael Pavone <pavone@retrodev.com> parents: 2364 diff changeset	1375 }
2169 cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1376 default:
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1377 return 0;
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1378 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1379 }
cb9572145f8e WIP support for expression parsing in debugger Michael Pavone <pavone@retrodev.com> parents: 2133 diff changeset	1380
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1381 char * find_param(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1382 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1383 for (; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1384 if (*buf == ' ') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1385 if (*(buf+1)) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1386 return buf+1;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1387 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1388 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1389 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1390 return NULL;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1391 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1392
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1393 void strip_nl(char * buf)
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1394 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1395 for(; *buf; buf++) {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1396 if (*buf == '\n') {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1397 *buf = 0;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1398 return;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1399 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1400 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1401 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	1402
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	1403 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	1404 {
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	1405 //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	1406 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	1407 }
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	1408
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1409 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	1410 {
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	1411 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	1412 }
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	1413
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1414 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	1415 {
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	1416 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	1417 }
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	1418
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1419 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	1420 {
2175 8c28c5466d70 Minor cleanup of debugger changes Michael Pavone <pavone@retrodev.com> parents: 2174 diff changeset	1421 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	1422 if (size == 'b') {
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1423 out = m68k_read_byte(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1424 } else if (size == 'l') {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1425 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1426 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	1427 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1428 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1429 out = m68k_read_long(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1430 } else {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1431 if (*out & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1432 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	1433 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1434 }
2170 ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1435 out = m68k_read_word(out, context);
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1436 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1437 return 1;
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1438 }
ada3130b1396 Add memory indirection syntax to debugger parser/evaluator Michael Pavone <pavone@retrodev.com> parents: 2169 diff changeset	1439
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1440 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	1441 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1442 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1443 if (size == 'b') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1444 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	1445 } else if (size == 'l') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1446 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1447 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	1448 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1449 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1450 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	1451 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	1452 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1453 if (address & 1) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1454 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	1455 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1456 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1457 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	1458 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1459 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1460 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1461
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1463 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1465 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	1466 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1467
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1469 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1471 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	1472 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	1473 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	1474 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	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 context->dregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1477 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1478
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1480 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1482 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	1483 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1484
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1486 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1488 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	1489 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	1490 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	1491 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	1492 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 context->aregs[var->val.v.u32] = ival;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1494 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1495
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1497 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1499 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	1500 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	1501 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	1502 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1506 return ret;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1507 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1508
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1509 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	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 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	1512 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	1513 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	1514 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	1515 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	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 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	1518 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	1519 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	1520 }
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1521 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 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 m68k_cycle_get(debug_var *var)
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1524 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1526 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	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 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	1530 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1532 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	1533 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1534
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1536 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1538 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	1539 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	1540 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	1541 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	1542 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1544 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 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 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	1547 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1549 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	1550 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1551
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1553 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1555 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	1556 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	1557 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	1558 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1559 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	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 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	1566 return debug_int(root->address);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1567 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1568
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1572 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	1573 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1575 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	1576 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	1577 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	1578 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	1579 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	1580 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	1581 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	1582 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	1583
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1584 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	1585 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	1586 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	1587 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	1588 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	1589 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	1590 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	1591 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	1592 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	1593 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	1594 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	1595 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	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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1600 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	1601 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	1602 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	1603 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	1604 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	1605
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1606 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	1607 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	1608 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	1609 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	1610 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	1611
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1612 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	1613 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	1614 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	1615 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	1616 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	1617 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	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 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	1620 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	1621 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	1622 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	1623 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	1624 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	1625
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1627 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	1628 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	1629 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	1630 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1631
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1632 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	1633 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1635 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	1636 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1637
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1638 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	1639 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1641 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	1642 }
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 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	1645 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1647 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	1648 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1649
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1650 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	1651 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1653 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	1654 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	1655 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	1656 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	1657 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1659 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1660
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1662 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1663 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	1664 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	1665 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1666
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1670 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	1671 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	1672 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	1673 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	1674 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1679 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1681 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	1682 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1683
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1684 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	1685 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1686 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	1687 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1691 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1693 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	1694 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	1695 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	1696 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1698 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1702 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1704 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	1705 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1706
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1710 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	1711 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	1712 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	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 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	1715 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1718 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	1719 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1720 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	1721 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	1722 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1723
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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 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	1727 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	1728 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	1729 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	1730 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1732 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	1733 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1734
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1736 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1738 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1742 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1743 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	1744 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	1745 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	1746 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	1747 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1748 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1750 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1751
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1753 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1754 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	1755 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	1756 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	1757 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	1758 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	1759
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1760 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	1761 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	1762 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	1763 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	1764
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1766 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	1767 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	1768 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	1769 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	1770
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	1772 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	1773 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	1774 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	1775 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	1776
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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, "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	1778 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	1779 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	1780 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	1781
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1782 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1783 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1784
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1785 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	1786 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1787 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	1788 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	1789 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1790
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1791 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	1792 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1793 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	1794 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	1795 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	1796 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	1797 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1798 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	1799 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	1800 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	1801 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	1802 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	1803 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	1804 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	1805 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	1806 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1807
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1808 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	1809 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1810 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	1811 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	1812 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1813
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1814 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	1815 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1816 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	1817 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	1818 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	1819 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	1820 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1821 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	1822 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	1823 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	1824 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	1825 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	1826 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	1827 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	1828 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	1829 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1830
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1831 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	1832 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1833 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	1834
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1835 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	1836 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	1837
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1838 return root;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1839 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1840
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1841
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1842 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	1843 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1844 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	1845 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	1846 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1847
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1848 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	1849 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1850 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	1851 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	1852 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	1853 return;
2360 053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1854 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1855 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	1856 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	1857 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1858
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1859 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	1860 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1861 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	1862 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	1863 }
053ba4551c62 Expose some more emu state via debugger array mechanism Michael Pavone <pavone@retrodev.com> parents: 2359 diff changeset	1864
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1865 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	1866 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1867 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	1868 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	1869 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	1870 return;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1871 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1872 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	1873 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	1874 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1875
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1876 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	1877 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1878 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	1879 return debug_int(psg->volume[index]);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1880 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1881
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1882 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	1883 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1884 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	1885 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	1886 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	1887 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	1888 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1889 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	1890 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	1891 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1892
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1893 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	1894 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1895 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	1896
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1897 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	1898 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	1899 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	1900
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	1901 return root;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1902 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	1903
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1904 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	1905 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1906 char *prefix = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1907 char * full = alloc_concat(prefix, key);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1908 fprintf(stderr, "\t%s\n", full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1909 free(full);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1910 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1911
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1912 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	1913 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1914 char *cur = text;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1915 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	1916 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1917 ++cur;
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 char *name = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1920 memcpy(name, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1921 name[cur-text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1922 uint8_t ret = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1923 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	1924 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	1925 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1926 tern_node *node = prefix_res;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1927 while (node)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1928 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1929 if (node->left \|\| node->right) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1930 break;
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 if (node->el) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1933 node = node->straight.next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1934 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1935 def = node->straight.value.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1936 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1937 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1938 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1939 if (!def && prefix_res) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1940 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	1941 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	1942 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1943 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1944 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1945 if (!def) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1946 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	1947 goto cleanup_name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1948 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1949 char *format = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1950 if (*cur == '/') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1951 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1952 text = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1953 while (cur && !isspace(cur))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1954 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1955 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1956 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1957 format = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1958 memcpy(format, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1959 format[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1960 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1961 int num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1962 command_arg *args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1963 if (cur && cur != '\n') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1964 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1965 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1966 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	1967 if (def->raw_args) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1968 while (cur && cur != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1969 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1970 ++cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1971 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1972 char *raw_param = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1973 if (cur != text) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1974 raw_param = malloc(cur - text + 1);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1975 memcpy(raw_param, text, cur - text);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1976 raw_param[cur - text] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1977 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1978 out->raw = raw_param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1979 out->args = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1980 out->num_args = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1981 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1982 int arg_storage = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1983 if (def->max_args > 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1984 arg_storage = def->max_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1985 } else if (def->max_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1986 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	1987 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1988 if (arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1989 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	1990 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1991 while (text && text != '\n')
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1992 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1993 char *after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1994 expr *e = parse_expression(text, &after);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1995 if (e) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1996 if (num_args == arg_storage) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1997 if (def->max_args >= 0) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1998 free_expr(e);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	1999 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	2000 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2001 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2002 arg_storage *= 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2003 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	2004 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2005 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2006 args[num_args].parsed = e;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2007 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	2008 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	2009 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	2010 text = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2011 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2012 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2013 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2014 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2015 if (num_args < def->min_args) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2016 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	2017 goto cleanup_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2018 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2019 out->raw = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2020 out->args = args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2021 out->num_args = num_args;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2022 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2023 out->def = def;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2024 out->format = format;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	2025
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2026 ret = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2027 cleanup_args:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2028 if (!ret) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2029 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	2030 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2031 free_expr(args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2032 free(args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2033 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2034 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	2035 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2036 cleanup_name:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2037 free(name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2038 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2039 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2040
2188 e17d99c96c89 Make blocks an 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 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	2042 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	2043 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2044 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	2045 {
e17d99c96c89 Make blocks an 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 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	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 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	2049 }
e17d99c96c89 Make blocks an 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
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2051 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	2052 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2053 free(cmd->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2054 free(cmd->raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2055 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	2056 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2057 free(cmd->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2058 free_expr(cmd->args[i].parsed);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2059 }
2188 e17d99c96c89 Make blocks an 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 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	2061 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	2062 free(cmd->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2063 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2064
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2065 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	2066 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	2067 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	2068 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	2069 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	2070 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	2071 };
e17d99c96c89 Make blocks an 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
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2073 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	2074 {
e17d99c96c89 Make blocks an 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 ++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	2076 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	2077 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2078 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	2079 }
e17d99c96c89 Make blocks an 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 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	2081 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	2082 #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	2083 #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	2084 #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	2085 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	2086 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	2087 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	2088 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	2089 #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	2090 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	2091 process_events();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	2092 #ifndef IS_LIB
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	2093 render_update_display();
2302 0343f0d5add0 Fix libretro build for real Michael Pavone <pavone@retrodev.com> parents: 2252 diff changeset	2094 #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	2095 #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	2096 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	2097 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	2098 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	2099 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	2100 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	2101 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2102 #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	2103 } 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	2104
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2105 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	2106 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	2107 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	2108 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	2109 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2110 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	2111 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	2112 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	2113 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2114 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	2115 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	2116 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	2117 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2118 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	2119 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	2120 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2121 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2122 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	2123 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	2124 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	2125 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2126 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	2127 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	2128 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	2129 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	2130 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	2131 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2132 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	2133 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	2134 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	2135 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2136 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	2137 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2138 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	2139 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	2140 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	2141 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	2142 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	2143 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	2144 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	2145 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	2146 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	2147 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	2148 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	2149 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2150 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	2151 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	2152 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	2153 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2154 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	2155 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	2156 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	2157 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	2158 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2159 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2160 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2161 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	2162 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2163
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2164 static uint8_t 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	2165 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2166 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	2167 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	2168 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2169 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	2170 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	2171 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	2172 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2173 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2174 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2175 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	2176 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2177
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2178 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	2179 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2180
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2181 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	2182 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	2183 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	2184 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	2185 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	2186 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	2187 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	2188 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2189 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	2190 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	2191 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2192 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	2193 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	2194 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	2195 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	2196 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	2197 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	2198 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2199 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	2200 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	2201 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	2202 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	2203 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	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 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	2206 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2207 }
2193 d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2208 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	2209 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	2210 } else {
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2211 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	2212 }
d00fb9c6a6a2 Fix a couple of debugger regressions introduced with changes to support blocks Michael Pavone <pavone@retrodev.com> parents: 2191 diff changeset	2213 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	2214 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2215
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2216 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	2217 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2218 exit(0);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2219 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2220
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2221 typedef struct {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2222 size_t num_commands;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2223 size_t longest_command;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2224 } help_state;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2225
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2226 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	2227 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2228 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2229 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2230 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2231 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2232 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2233 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2234 state->num_commands++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2235 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2236 if (len > state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2237 state->longest_command = len;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2238 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2239 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2240
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2241 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	2242 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2243 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2244 def->visited = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2245 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2246
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2247 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	2248 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2249 command_def *def = val.ptrval;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2250 if (def->visited) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2251 return;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2252 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2253 def->visited = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2254 help_state *state = data;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2255 size_t len = strlen(def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2256 printf(" %s", def->usage);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2257 while (len < state->longest_command) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2258 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2259 len++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2260 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2261 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	2262 const char *extra_desc = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2263 if (strlen(def->desc) <= remaining) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2264 printf(" - %s\n", def->desc);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2265 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2266 char split[76];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2267 int split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2268 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	2269 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2270 --split_point;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2271 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2272 if (!split_point) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2273 split_point = remaining;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2274 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2275 memcpy(split, def->desc, split_point);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2276 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	2277 split[split_point] = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2278 printf(" - %s\n", split);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2279 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2280 if (def->names[1]) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2281 fputs(" Aliases: ", stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2282 len = strlen(" Aliases: ");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2283 const char **name = def->names + 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2284 uint8_t first = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2285 while (*name)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2286 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2287 if (first) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2288 first = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2289 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2290 putchar(',');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2291 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2292 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	2293 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2294 fputs(*name, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2295 len += strlen(*name);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2296 ++name;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2297 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2298 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2299 len = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2300 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2301 if (extra_desc) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2302 while (len < state->longest_command + 5) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2303 putchar(' ');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2304 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	2305 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2306 fputs(extra_desc, stdout);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2307 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2308 putchar('\n');
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2309 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2310
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2311 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	2312 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2313 help_state state = {0,0};
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2314 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	2315 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	2316 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	2317 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	2318 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2319 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2320
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2321 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	2322 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2323 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2324 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2325
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2326 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	2327 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2328 strcpy(format_str, "%s: %d\n");
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2329 if (format) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2330 switch (format[0])
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2331 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2332 case 'x':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2333 case 'X':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2334 case 'd':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2335 case 'c':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2336 case 's':
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2337 format_str[5] = format[0];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2338 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2339 default:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2340 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	2341 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2342 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2343 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2344
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2345 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	2346 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2347 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	2348 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2350 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	2351 char tmp[128];
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2352 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	2353 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	2354 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	2355 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2357 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	2358 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	2359 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	2360 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	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 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	2363 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2365 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	2366 } 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	2367 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	2368 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2370 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	2371 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	2372 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	2373 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	2374 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	2375 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	2376 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2377 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2378 }
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2379
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2380 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	2381 {
e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2382 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	2383 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	2384 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	2385 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2386 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	2387 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2388 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2389 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2390
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2391 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	2392 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2393 char *param = cmd->raw;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2394 if (!param) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2395 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	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 while (isblank(*param))
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2399 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2400 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2401 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2402 if (*param != '"') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2403 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	2404 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2405 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2406 ++param;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2407 char *fmt = strdup(param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2408 char cur = param, out = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2409 while (cur && cur != '"')
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2410 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2411 if (*cur == '\\') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2412 switch (cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2413 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2414 case 't':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2415 *(out++) = '\t';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2416 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2417 case 'n':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2418 *(out++) = '\n';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2419 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2420 case 'r':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2421 *(out++) = '\r';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2422 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2423 case '\\':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2424 *(out++) = '\\';
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2425 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2426 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2427 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	2428 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2429 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2430 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2431 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2432 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2433 (out++) = (cur++);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2434 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2435 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2436 *out = 0;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2437 ++cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2438 param = cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2439 cur = fmt;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2440 char format_str[3] = {'%', 'd', 0};
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2441 while (*cur)
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2442 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2443 if (*cur == '%') {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2444 switch(cur[1])
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2445 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2446 case 'x':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2447 case 'X':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2448 case 'c':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2449 case 'd':
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2450 case 's':
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2451 case 'f':
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2452 break;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2453 default:
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2454 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	2455 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2456 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2457 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2458 format_str[1] = cur[1];
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2459 expr *arg = parse_expression(param, &param);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2460 if (!arg) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2461 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2462 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2463 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 debug_val val;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2465 if (!eval_expr(root, arg, &val)) {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2466 free(fmt);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2467 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2468 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2469 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	2470 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	2471 //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	2472 } 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	2473 char tmp[128];
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2474 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	2475 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	2476 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	2477 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	2478 return 1;
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2479 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2480 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	2481 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	2482 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2483 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	2484 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	2485 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	2486 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	2487 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	2488 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2489 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	2490 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2492 printf(format_str, tmp);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2493 }
2363 b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2494 } else if (cur[1] == 'f') {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2495 float fval;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2496 if (!debug_cast_float(val, &fval)) {
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2497 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	2498 free(fmt);
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2499 return 1;
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2500 }
b865f33fd47e Basic float support in debug language Michael Pavone <pavone@retrodev.com> parents: 2362 diff changeset	2501 printf(format_str, fval);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2502 } 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	2503 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	2504 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	2505 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	2506 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	2507 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	2508 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2509 printf(format_str, ival);
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2510 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2511 cur += 2;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2512 } else {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2513 putchar(*cur);
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2514 ++cur;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2515 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2516 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2517 return 1;
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2518 }
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	2519
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2520 static uint8_t cmd_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	2521 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2522 cmd_print(root, cmd);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2523 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	2524 ndisp->next = root->displays;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2525 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	2526 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	2527 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	2528 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	2529 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	2530 cmd->num_args = 0;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2531 root->displays = ndisp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2532 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	2533 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2534 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2535
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2536 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	2537 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2538 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	2539 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	2540 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	2541 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	2542 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	2543 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2544 while (*cur)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2545 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2546 if ((*cur)->index == index) {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2547 disp_def del_disp = cur;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2548 *cur = del_disp->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2549 free(del_disp->format);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2550 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	2551 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2552 free(del_disp->args[i].raw);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2553 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	2554 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2555 free(del_disp->args);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2556 free(del_disp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2557 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2558 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2559 cur = &(*cur)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2560 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2561 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2562 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2563 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2564
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2565 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	2566 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2567 if (current_system->soft_reset) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2568 current_system->soft_reset(current_system);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2569 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2570 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2571 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	2572 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2573 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2574 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2575
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2576 static uint8_t cmd_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	2577 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2578 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	2579 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	2580 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	2581 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	2582 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2583 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	2584 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	2585 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	2586 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2587 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2588 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	2589 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2590 free_parsed_command((*target)->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2591 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2592 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	2593 (*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	2594 (*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	2595 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	2596 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	2597 return 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2598 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2599
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2600 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	2601 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2602 uint8_t debugging = 1;
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2603 for (int i = 0; i < block->num_commands && debugging; i++)
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2604 {
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2605 debugging = run_command(root, block->commands + i);
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2606 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2607 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2608 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2609
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2610 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	2611 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2613 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2614
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2615 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	2616 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2617 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	2618 return execute_block(root, &cmd->else_block);
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2619 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2620 int debugging = 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2621 do {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2622 debugging = execute_block(root, &cmd->block) && debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2623 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	2624 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	2625 return 1;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 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 } 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	2628 return debugging;
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2629 }
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	2630
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2631 const char *expr_type_names[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2632 "EXPR_NONE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2633 "EXPR_SCALAR",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2634 "EXPR_UNARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2635 "EXPR_BINARY",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2636 "EXPR_SIZE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2637 "EXPR_MEM"
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2638 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2639
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2640 static uint8_t cmd_function(debug_root root, parsed_command cmd)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2641 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2642 debug_root *set_root = root;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2643 expr *set_expr = cmd->args[0].parsed;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2644 while (set_expr->type == EXPR_NAMESPACE)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2645 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2646 set_root = tern_find_ptr(set_root->other_roots, set_expr->op.v.str);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2647 if (!set_root) {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2648 fprintf(stderr, "%s is not a valid namespace\n", set_expr->op.v.str);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2649 return 1;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2650 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2651 set_expr = set_expr->left;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2652 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2653 if (set_expr->type != EXPR_SCALAR \|\| set_expr->op.type != TOKEN_NAME) {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2654 fprintf(stderr, "Arguments to function must be names, bug argument 0 is %s\n", expr_type_names[set_expr->type]);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2655 return 1;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2656 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2657 debug_var *var = tern_find_ptr(set_root->variables, set_expr->op.v.str);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2658 if (var) {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2659 fprintf(stderr, "%s is already defined\n", set_expr->op.v.str);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2660 return 1;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2661 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2662 for (uint32_t i = 1; i < cmd->num_args; i++)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2663 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2664 if (cmd->args[i].parsed->type != EXPR_SCALAR \|\| cmd->args[i].parsed->op.type != TOKEN_NAME) {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2665 fprintf(stderr, "Arguments to function must be names, bug argument %d is %s\n", i, expr_type_names[cmd->args[i].parsed->type]);
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2666 return 1;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2667 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2668 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2669 char *args = calloc(cmd->num_args - 1, sizeof(char ));
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2670 for (uint32_t i = 1; i < cmd->num_args; i++)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2671 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2672 args[i - 1] = cmd->args[i].parsed->op.v.str;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2673 cmd->args[i].parsed->op.v.str = NULL;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2674 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2675 new_readonly_variable(set_root, set_expr->op.v.str, new_user_func(&cmd->block, args, cmd->num_args - 1));
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2676 cmd->block.commands = NULL;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2677 cmd->block.num_commands = 0;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2678 return 1;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2679 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2680
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2681 static uint8_t cmd_return(debug_root root, parsed_command cmd)
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2682 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2683 root->retval = cmd->args[0].value;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2684 return 0;
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2685 }
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	2686
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2687 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	2688 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2689 char *name = NULL;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2690 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	2691 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	2692 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	2693 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	2694 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2696 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	2697 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	2698 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	2699 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2700 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	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 debug_val address;
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2703 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	2704 switch (set_expr->type)
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2705 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2706 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	2707 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	2708 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	2709 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2710 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	2711 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2712 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2713 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2714 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	2715 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	2716 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	2717 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	2718 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2719 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	2720 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2721 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2722 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2723 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	2724 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	2725 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	2726 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	2727 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2728 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2729 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	2730 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	2731 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	2732 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2734 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	2735 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	2736 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	2737 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2738 array = get_array(right);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2739 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	2740 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	2741 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2742 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2743 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	2744 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	2745 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2746 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2747 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	2748 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	2749 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2750 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2751 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2752 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2753 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	2754 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	2755 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 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[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	2758 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	2759 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 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 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	2762 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	2763 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	2764 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	2765 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	2766 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	2767 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2768 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	2769 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	2770 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2771 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2772 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	2773 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	2774 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	2775 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	2776 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	2777 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	2778 } 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	2779 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	2780 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	2781 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	2782 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2783 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2784 var->set(var, value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2785 } 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	2786 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	2787 } 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	2788 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	2789 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2790 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2791 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	2792
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	2793 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	2794 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2795 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	2796 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	2797 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	2798 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2799 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	2800 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	2801 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	2802 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	2803 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2804 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	2805 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2806 if (set_expr->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	2807 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	2808 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	2809 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2810 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	2811 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	2812 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	2813 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	2814 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2815 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	2816 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	2817 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	2818 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	2819 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	2820 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	2821 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	2822 }
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	2823 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	2824 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2825 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	2826 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	2827 }
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	2828
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2829 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	2830 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2831 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	2832 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	2833 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	2834 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2835 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	2836 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	2837 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	2838 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	2839 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2841 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2843 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	2844 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2845 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2846 debug_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	2847 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	2848 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	2849 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	2850 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	2851 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	2852 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	2853 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	2854 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2855 } 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	2856 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	2857 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	2858 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	2859 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	2860 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	2861 array = get_array(var->val);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2862 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2863 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	2864 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	2865 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	2866 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	2867 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	2868 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 }
2367 48cc69b4c358 Add some more builtin functions to debugger language Michael Pavone <pavone@retrodev.com> parents: 2366 diff changeset	2870 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	2871 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2872 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	2873 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	2874 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2875 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2876 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	2877 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2878 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2879 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2880
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2881 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	2882 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2883 debug_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	2884 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	2885 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	2886 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2887 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2888 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	2889 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	2890 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2891 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2892 array->append(array, cmd->args[1].value);
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2893 return 1;
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2894 }
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	2895
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2896 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	2897 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2898 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	2899 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	2900 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	2901 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	2902 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	2903 current_system->enter_debugger_frames = frames;
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2904 return 0;
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2905 }
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	2906
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2907 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	2908 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2909 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	2910 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	2911 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2912 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2913 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2914
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2915 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	2916 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2917 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	2918 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	2919 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2920 return 1;
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2921 }
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	2922
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2923 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	2924 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	2925 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	2926 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	2927 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2928 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2930 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	2931 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	2932 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	2933 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	2935 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	2936 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	2937 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2938 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2939 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	2940 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	2941 (*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	2942 cmd->args[1].parsed = NULL;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2943 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2944 (*target)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2945 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2946 return 1;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2947 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	2948
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2949 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	2950 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2951 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	2952 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	2953 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	2954 *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	2955 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2956 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2957
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2958 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	2959 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2960 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	2961 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	2962 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	2963 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	2964 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2965 putchar(' ');
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2966 len++;
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2967 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2968 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	2969 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2970
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2971 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	2972 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2973 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	2974 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	2975 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	2976 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	2977 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	2978 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	2979 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2980 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	2981 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	2982 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2983 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	2984 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	2985 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	2986 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	2987 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	2988 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	2989 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	2990 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	2991 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	2992 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2993 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2994 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2995 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2996 } else {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	2997 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	2998 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	2999 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	3000 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	3001 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3002 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	3003 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3004
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3005 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	3006 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3007 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	3008 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	3009 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	3010 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	3011 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3012 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	3013 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	3014 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	3015 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3016 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3017 bp_def tmp = this_bp;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3018 if (tmp->type == BP_TYPE_CPU) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3019 remove_breakpoint(root->cpu_context, tmp->address);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3020 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3021 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3022 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3023 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	3024 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3025 free_parsed_command(tmp->commands + i);
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 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3028 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3029 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3030 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3031 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3032
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3033 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	3034 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3035 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	3036 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	3037 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	3038 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	3039 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3040 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	3041 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	3042 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	3043 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3044 new_bp->mask = 0xFFFFFF;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3045 new_bp->index = root->bp_index++;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3046 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	3047 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	3048 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	3049 return 1;
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
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3052 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	3053 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3054 value &= 0xFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3055 if (context->regs[reg] == value) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3056 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3057 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3058 genesis_context gen = (genesis_context )context->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3059 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	3060 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	3061 int debugging = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3062 if (*this_bp) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3063 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	3064 debug_val condres;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3065 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	3066 if (!condres.v.u32) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3067 return;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3068 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3069 } else {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3070 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	3071 free_expr((*this_bp)->condition);
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3072 (*this_bp)->condition = NULL;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3073 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3074 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3075 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	3076 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3077 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	3078 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3079 if (debugging) {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3080 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	3081 gen->header.enter_debugger = 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3082 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	3083 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	3084 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3085 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	3086 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	3087 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3088 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3089 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3090 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3091
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3092 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	3093 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3094 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	3095 new_bp->next = root->breakpoints;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3096 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	3097 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	3098 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	3099 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	3100 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3101 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	3102 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	3103 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	3104 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	3105 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3106 } 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	3107 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	3108 }
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3109 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3110 new_bp->index = root->bp_index++;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3111 new_bp->type = BP_TYPE_VDPREG;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3112 root->breakpoints = new_bp;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3113 m68k_context *m68k = root->cpu_context;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3114 genesis_context *gen = m68k->system;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3115 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	3116 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	3117 return 1;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3118 }
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3119
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3120 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	3121 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3122 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	3123 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	3124 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	3125 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	3126 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3127 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	3128 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3129 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3130
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3131 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	3132 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3133 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3134 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3135 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3136 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3137 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	3138 } 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	3139 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	3140 } else if(m68k_is_branch(inst)) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3141 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	3142 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3143 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	3144 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	3145 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3146 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3147 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	3148 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	3149 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3150 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3151 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3152 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	3153 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	3154 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3155 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3156 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	3157 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3158 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3159 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	3160 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3161 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3162
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3163 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	3164 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3165 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3166 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3167 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3168 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3169 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	3170 } 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	3171 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	3172 } 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	3173 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	3174 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	3175 if (root->branch_t < after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3176 root->branch_t = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3177 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3178 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3179 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	3180 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3181 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3182 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	3183 if (target > after) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3184 if (inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3185 after = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3186 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3187 root->branch_f = target;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3188 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3189 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	3190 }
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 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3193 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	3194 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3195 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3196 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	3197 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3198 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3199
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3200 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	3201 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3202 m68kinst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3203 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3204 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3205 if (inst->op == M68K_RTS) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3206 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	3207 } 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	3208 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	3209 } 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	3210 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	3211 root->branch_f = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3212 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	3213 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	3214 } else if(inst->op == M68K_DBCC) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3215 if ( inst->extra.cond == COND_FALSE) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3216 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	3217 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	3218 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3219 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3220 root->branch_t = after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3221 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	3222 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	3223 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3224 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3225 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	3226 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3227 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3228 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	3229 return 0;
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
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3232 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	3233 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3234 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3235 uint32_t stack = context->aregs[7];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3236 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3237 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3238 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	3239 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	3240 if (bt_address) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3241 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3242 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3243 m68kinst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3244 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3245 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	3246 m68k_disasm(&inst, buf);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3247 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	3248 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3249 //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	3250 stack += 2;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3251 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3252 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3253 //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	3254 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3255 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3256 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3257
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3258 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	3259 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3260 m68k_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3261 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3262 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	3263 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	3264 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	3265 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	3266 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3267 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3268 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3269 m68kinst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3270 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3271 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3272 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3273 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	3274 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3275 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3276 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3277 }
2252 6a07b13894f7 Fix input processing while waiting for console input in debugger Michael Pavone <pavone@retrodev.com> parents: 2216 diff changeset	3278
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3279 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3280 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3281 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3282 } while(!m68k_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3283 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3284 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3285
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3286 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	3287 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3288 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3289 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3290 vdp_print_sprite_table(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3291 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3292 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3293
2188 e17d99c96c89 Make blocks an 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 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	3295 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3296 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3297 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3298 vdp_print_reg_explain(gen->vdp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3299 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3300 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3301
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3302 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	3303 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3304 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3305 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	3306 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	3307 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	3308 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3309 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	3310 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	3311 }
2173 894c7873a2b1 Consume all expressions in debugger print command Michael Pavone <pavone@retrodev.com> parents: 2172 diff changeset	3312 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3313 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3314 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3315
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3316 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	3317 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3318 m68k_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3319 genesis_context * gen = context->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3320 ym_print_timer_info(gen->ym);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3321 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3322 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3323
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3324 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	3325 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3326 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3327 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3328 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3329 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3330 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3331 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3332 genesis_context *gen = m68k->system;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3333 segacd_context *cd = gen->expansion;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3334 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	3335 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3336 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	3337 if (!sub_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3338 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	3339 return 1;
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 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	3342 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3343 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3344 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	3345 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3346 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3347 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3348 cd->enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3349 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3350 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3351 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3352
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3353 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	3354 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3355 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3356 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3357 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3358 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3359 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3360 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3361 segacd_context *cd = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3362
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3363 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	3364 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3365 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	3366 if (!main_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3367 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	3368 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3369 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3370 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	3371 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3372 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3373 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	3374 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3375 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3376 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3377 cd->genesis->header.enter_debugger = 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3378 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3379 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3380 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3381
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3382 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	3383 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3384 char *param = cmd->raw;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3385 while (param && param && isblank(param))
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3386 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3387 ++param;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3388 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3389 m68k_context *m68k = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3390 genesis_context *gen = m68k->system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	3391
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3392 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	3393 parsed_command cmd = {0};
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3394 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	3395 if (!z80_root) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3396 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	3397 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3398 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3399 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	3400 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3401 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3402 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	3403 free_parsed_command(&cmd);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3404 return ret;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3405 } else {
2184 408fb8a7e990 Implement argumentless variant of z80 debugger command Michael Pavone <pavone@retrodev.com> parents: 2183 diff changeset	3406 gen->enter_z80_debugger = 1;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3407 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3408 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3409 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3410
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3411 command_def common_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3412 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3413 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3414 "quit", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3415 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3416 .usage = "quit",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3417 .desc = "Quit BlastEm",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3418 .impl = cmd_quit,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3419 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3420 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3421 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3422 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3423 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3424 "help", "?", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3425 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3426 .usage = "help",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3427 .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	3428 .impl = cmd_help,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3429 .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	3430 .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	3431 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3432 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3433 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3434 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3435 "continue", "c", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3436 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3437 .usage = "continue",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3438 .desc = "Resume execution",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3439 .impl = cmd_continue,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3440 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3441 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3442 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3443 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3444 .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	3445 "print", "p", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3446 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3447 .usage = "print[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3448 .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	3449 .impl = cmd_print,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3450 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3451 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3452 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3453 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3454 .names = (const char *[]){
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3455 "printf", NULL
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3456 },
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3457 .usage = "printf FORMAT EXPRESSION...",
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3458 .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	3459 .impl = cmd_printf,
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3460 .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	3461 .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	3462 .raw_args = 1
2187 d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3463 },
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3464 {
d0129f19ca52 Add a printf command to the debugger Michael Pavone <pavone@retrodev.com> parents: 2186 diff changeset	3465 .names = (const char *[]){
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3466 "softreset", "sr", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3467 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3468 .usage = "softreset",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3469 .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	3470 .impl = cmd_softreset,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3471 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3472 .max_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3473 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3474 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3475 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3476 "display", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3477 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3478 .usage = "display[/FORMAT] EXPRESSION...",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3479 .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	3480 .impl = cmd_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3481 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3482 .max_args = -1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3483 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3484 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3485 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3486 "deletedisplay", "dd", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3487 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3488 .usage = "deletedisplay DISPLAYNUM",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3489 .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	3490 .impl = cmd_delete_display,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3491 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3492 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3493 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3494 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3495 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3496 "commands", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3497 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3498 .usage = "command BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3499 .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	3500 .impl = cmd_command,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3501 .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	3502 .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	3503 .has_block = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3504 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3505 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3506 .names = (const char *[]){
2371 1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3507 "function", NULL
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3508 },
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3509 .usage = "function NAME [ARGS...]",
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3510 .desc = "Creates a user-defined function named NAME with arguments ARGS",
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3511 .impl = cmd_function,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3512 .min_args = 1,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3513 .max_args = -1,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3514 .has_block = 1,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3515 .skip_eval = 1
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3516 },
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3517 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3518 .names = (const char *[]){
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3519 "return", NULL
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3520 },
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3521 .usage = "return VALUE",
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3522 .desc = "Return from a user defined function with the result VALUE",
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3523 .impl = cmd_return,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3524 .min_args = 1,
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3525 .max_args = 1
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3526 },
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3527 {
1fe5afe263f3 Initial stab at user-defined functions in debugger language Michael Pavone <pavone@retrodev.com> parents: 2367 diff changeset	3528 .names = (const char *[]){
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3529 "set", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3530 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3531 .usage = "set MEM\|NAME VALUE",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3532 .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	3533 .impl = cmd_set,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3534 .min_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3535 .max_args = 2,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3536 .skip_eval = 1
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3537 },
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3538 {
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3539 .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	3540 "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	3541 },
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	3542 .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	3543 .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	3544 .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	3545 .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	3546 .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	3547 .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	3548 },
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	3549 {
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	3550 .names = (const char *[]){
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3551 "array", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3552 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3553 .usage = "array NAME [VALUE...]",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3554 .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	3555 .impl = cmd_array,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3556 .min_args = 1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3557 .max_args = -1,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3558 .skip_eval = 1
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3559 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3560 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3561 .names = (const char *[]){
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3562 "append", NULL
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3563 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3564 .usage = "append NAME VALUE",
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3565 .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	3566 .impl = cmd_append,
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3567 .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	3568 .max_args = 2
2359 04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3569 },
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3570 {
04d29635d238 Support for arrays in debugger language Michael Pavone <pavone@retrodev.com> parents: 2358 diff changeset	3571 .names = (const char *[]){
2179 9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3572 "frames", NULL
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3573 },
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3574 .usage = "frames EXPRESSION",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3575 .desc = "Resume execution for EXPRESSION video frames",
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3576 .impl = cmd_frames,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3577 .min_args = 1,
9a8dd4ba2753 Implement frame advance debugger command Michael Pavone <pavone@retrodev.com> parents: 2178 diff changeset	3578 .max_args = 1
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3579 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3580 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3581 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3582 "bindup", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3583 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3584 .usage = "bindup NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3585 .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	3586 .impl = cmd_bindup,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3587 .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	3588 .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	3589 .raw_args = 1
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3590 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3591 {
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3592 .names = (const char *[]){
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3593 "binddown", NULL
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3594 },
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3595 .usage = "bindown NAME",
0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3596 .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	3597 .impl = cmd_binddown,
2181 0c723b8b637c Add bindup and binddown debugger commands Michael Pavone <pavone@retrodev.com> parents: 2180 diff changeset	3598 .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	3599 .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	3600 .raw_args = 1
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3601 },
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3602 {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3603 .names = (const char *[]){
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3604 "condition", NULL
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3605 },
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3606 .usage = "condition BREAKPOINT [EXPRESSION]",
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3607 .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	3608 .impl = cmd_condition,
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	3609 .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	3610 .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	3611 .skip_eval = 1
2190 59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3612 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3613 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3614 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3615 "if", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3616 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3617 .usage = "if CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3618 .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	3619 .impl = cmd_if,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3620 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3621 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3622 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3623 .accepts_else = 1
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3624 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3625 {
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3626 .names = (const char *[]){
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3627 "while", NULL
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3628 },
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3629 .usage = "while CONDITION",
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3630 .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	3631 .impl = cmd_while,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3632 .min_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3633 .max_args = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3634 .has_block = 1,
59e0dcc01b2c Add 'if' and 'while' debugger commands Michael Pavone <pavone@retrodev.com> parents: 2189 diff changeset	3635 .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	3636 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3637 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3638 .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	3639 "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	3640 },
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	3641 .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	3642 .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	3643 .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	3644 .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	3645 .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	3646 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3647 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3648 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3649 #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	3650
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3651 command_def m68k_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3652 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3653 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3654 "breakpoint", "b", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3655 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3656 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3657 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3658 .impl = cmd_breakpoint_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3659 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3660 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3661 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3662 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3663 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3664 "advance", NULL
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 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3667 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3668 .impl = cmd_advance_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3669 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3670 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3671 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3672 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3673 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3674 "step", "s", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3675 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3676 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3677 .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	3678 .impl = cmd_step_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3679 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3680 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3681 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3682 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3683 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3684 "over", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3685 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3686 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3687 .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	3688 .impl = cmd_over_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3689 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3690 .max_args = 0
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 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3693 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3694 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3695 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3696 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3697 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3698 .impl = cmd_next_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3699 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3700 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3701 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3702 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3703 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3704 "backtrace", "bt", NULL
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 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3707 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3708 .impl = cmd_backtrace_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3709 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3710 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3711 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3712 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3713 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3714 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3715 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3716 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3717 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3718 .impl = cmd_delete_m68k,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3719 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3720 .max_args = 1
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3721 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3722 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3723 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3724 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3725 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3726 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3727 .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	3728 .impl = cmd_disassemble_m68k,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3729 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3730 .max_args = 1
2112 3abb64bd0da6 Add support for printing strings in 68K debugger Michael Pavone <pavone@retrodev.com> parents: 2107 diff changeset	3731 }
2178 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 #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	3735
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3736 command_def genesis_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3737 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3738 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3739 "vdpsprites", "vs", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3740 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3741 .usage = "vdpsprites",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3742 .desc = "Print the VDP sprite table",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3743 .impl = cmd_vdp_sprites,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3744 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3745 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3746 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3747 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3748 .names = (const char *[]){
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3749 "vdpregs", "vr", NULL
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3750 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3751 .usage = "vdpregs",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3752 .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	3753 .impl = cmd_vdp_regs,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3754 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3755 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3756 },
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3757 {
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3758 .names = (const char *[]){
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3759 "vdpregbreak", "vregbreak", "vrb", NULL
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3760 },
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3761 .usage = "vdpregbreak [REGISTER [MASK]]",
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3762 .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	3763 .impl = cmd_vdp_reg_break,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3764 .min_args = 0,
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3765 .max_args = 2
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3766 },
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3767 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3768 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3769 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3770 "z80", NULL
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 .usage = "z80 [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3773 .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	3774 .impl = cmd_gen_z80,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3775 .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	3776 .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	3777 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3778 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3779 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3780 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3781 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3782 "ymchannel", "yc", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3783 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3784 .usage = "ymchannel [CHANNEL]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3785 .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	3786 .impl = cmd_ym_channel,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3787 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3788 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3789 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3790 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3791 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3792 "ymtimer", "yt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3793 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3794 .usage = "ymtimer",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3795 .desc = "Print YM-2612 timer info",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3796 .impl = cmd_ym_timer,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3797 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3798 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3799 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3800 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3801
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3802 #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	3803
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3804 command_def scd_main_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3805 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3806 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3807 "subcpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3808 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3809 .usage = "subcpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3810 .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	3811 .impl = cmd_sub,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3812 .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	3813 .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	3814 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3815 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3816 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3817
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3818 #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	3819
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3820 command_def scd_sub_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3821 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3822 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3823 "maincpu", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3824 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3825 .usage = "maincpu [COMMAND]",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3826 .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	3827 .impl = cmd_main,
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3828 .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	3829 .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	3830 .raw_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3831 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3832 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3833
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3834 #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	3835
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3836 #ifndef NO_Z80
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3837
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3838 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	3839 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3840 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	3841 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	3842 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	3843 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	3844 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3845 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	3846 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	3847 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	3848 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3849 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3850 bp_def tmp = this_bp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3851 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	3852 this_bp = (this_bp)->next;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3853 if (tmp->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3854 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	3855 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3856 free_parsed_command(tmp->commands + i);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3857 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3858 free(tmp->commands);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3859 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3860 free(tmp);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3861 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3862 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3863
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3864 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	3865 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3866 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	3867 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	3868 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	3869 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	3870 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3871 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	3872 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	3873 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	3874 new_bp->address = address;
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3875 new_bp->mask = 0xFFFF;
3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	3876 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	3877 new_bp->index = root->bp_index++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3878 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	3879 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	3880 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3881 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3882
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3883 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	3884 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3885 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	3886 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	3887 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	3888 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	3889 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	3890 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	3891 return 0;
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
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3894 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	3895 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3896 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3897 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3898 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3899 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3900 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	3901 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3902 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3903 } 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	3904 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3905 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	3906 } 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	3907 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	3908 } 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	3909 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	3910 #endif
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 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3913 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3914 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3915 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	3916 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3917 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3918 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	3919 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3920 after \|= *sp << 8;
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 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3924 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	3925 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3926 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3927
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3928 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	3929 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3930 fputs("not implemented yet\n", stderr);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3931 return 1;
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
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3934 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	3935 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3936 z80inst *inst = root->inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3937 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3938 uint32_t after = root->after;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3939 //TODO: handle conditional branches
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3940 if (inst->op == Z80_JP) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3941 if (inst->addr_mode == Z80_IMMED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3942 after = inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3943 } 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	3944 #ifndef NEW_CORE
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3945 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	3946 } 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	3947 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	3948 } 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	3949 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	3950 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3951 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3952 } else if(inst->op == Z80_JR) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3953 after += inst->immed;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3954 } else if(inst->op == Z80_RET) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3955 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	3956 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3957 after = *sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3958 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	3959 if (sp) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3960 after \|= *sp << 8;
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 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	3965 return 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3966 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3967
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	3968 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	3969 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3970 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3971 uint32_t stack = context->sp;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3972 uint8_t non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3973 do {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3974 uint32_t bt_address = stack;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3975 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	3976 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3977 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3978 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	3979 if (bt_address != 0xFEEDFEED) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3980 stack += 4;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3981 non_adr_count = 0;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3982 z80inst inst;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3983 char buf[128];
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3984 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	3985 z80_decode(pc, &inst);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3986 z80_disasm(&inst, buf, bt_address);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3987 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	3988 } else {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3989 //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	3990 stack++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3991 non_adr_count++;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3992 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3993 //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	3994 } while (stack && non_adr_count < 6);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3995 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3996 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	3997
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	3998 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	3999 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4000 z80_context *context = root->cpu_context;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4001 uint32_t address = root->address;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4002 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	4003 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	4004 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	4005 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	4006 }
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4007 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4008 char disasm_buf[1024];
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4009 z80inst inst;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4010 do {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4011 label_def *def = find_label(root->disasm, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4012 if (def) {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4013 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	4014 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4015 printf("%s:\n", def->labels[i]);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4016 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4017 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4018 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	4019 uint8_t *after = z80_decode(pc, &inst);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4020 z80_disasm(&inst, disasm_buf, address);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4021 address += after - pc;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4022 printf("\t%s\n", disasm_buf);
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4023 } while(!z80_is_terminal(&inst));
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4024 return 1;
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4025 }
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4026
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4027 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	4028 {
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4029 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	4030 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	4031 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4032 ++param;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4033 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4034 genesis_context gen = (genesis_context )current_system;
2186 935e684f2d58 Fix crash bug in expression parser Michael Pavone <pavone@retrodev.com> parents: 2185 diff changeset	4035
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4036 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	4037 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	4038 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	4039 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	4040 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	4041 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4042 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4043 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	4044 return 1;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4045 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4046 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	4047 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	4048 return ret;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4049 } else {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4050 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	4051 return 0;
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4052 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4053 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4054
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4055 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	4056 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4057 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	4058 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	4059 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	4060 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4061 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4062
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4063 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	4064 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4065 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	4066 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	4067 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	4068 return 1;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4069 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4070
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4071 command_def z80_commands[] = {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4072 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4073 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4074 "breakpoint", "b", NULL
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 .usage = "breakpoint ADDRESSS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4077 .desc = "Set a breakpoint at ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4078 .impl = cmd_breakpoint_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4079 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4080 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4081 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4082 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4083 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4084 "advance", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4085 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4086 .usage = "advance ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4087 .desc = "Advance to ADDRESS",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4088 .impl = cmd_advance_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4089 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4090 .max_args = 1
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4091 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4092 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4093 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4094 "step", "s", NULL
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 .usage = "step",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4097 .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	4098 .impl = cmd_step_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4099 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4100 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4101 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4102 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4103 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4104 "over", NULL
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 .usage = "over",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4107 .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	4108 .impl = cmd_over_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4109 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4110 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4111 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4112 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4113 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4114 "next", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4115 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4116 .usage = "next",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4117 .desc = "Advance to the next instruction",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4118 .impl = cmd_next_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4119 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4120 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4121 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4122 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4123 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4124 "backtrace", "bt", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4125 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4126 .usage = "backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4127 .desc = "Print a backtrace",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4128 .impl = cmd_backtrace_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4129 .min_args = 0,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4130 .max_args = 0
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4131 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4132 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4133 .names = (const char *[]){
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4134 "delete", "d", NULL
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4135 },
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4136 .usage = "delete BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4137 .desc = "Remove breakpoint identified by BREAKPOINT",
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4138 .impl = cmd_delete_z80,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4139 .min_args = 1,
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4140 .max_args = 1
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4141 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4142 {
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4143 .names = (const char *[]){
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4144 "disassemble", "disasm", NULL
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4145 },
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4146 .usage = "disassemble [ADDRESS]",
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4147 .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	4148 .impl = cmd_disassemble_z80,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4149 .min_args = 0,
4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4150 .max_args = 1
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4151 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4152 };
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4153
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4154 #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	4155
2185 3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4156 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	4157 {
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4158 .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	4159 "m68k", NULL
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4160 },
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4161 .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	4162 .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	4163 .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	4164 .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	4165 .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	4166 .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	4167 }
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4168 };
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4169
3d2cc2af1da3 Add an m68k command for switching back to 68K debugger from Z80 Michael Pavone <pavone@retrodev.com> parents: 2184 diff changeset	4170 #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	4171
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4172 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	4173 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4174 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4175 "vdpsprites", "vs", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4176 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4177 .usage = "vdpsprites",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4178 .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	4179 .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	4180 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4181 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4182 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4183 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4184 .names = (const char *[]){
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4185 "vdpsregs", "vr", NULL
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4186 },
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4187 .usage = "vdpregs",
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4188 .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	4189 .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	4190 .min_args = 0,
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4191 .max_args = 0
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4192 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4193 };
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4194
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4195 #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	4196
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4197 #endif
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4198
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4199 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	4200 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4201 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	4202 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4203 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	4204 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4205 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	4206 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4207 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4208 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4209
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4210 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	4211 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4212 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	4213 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	4214 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	4215 {
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4216 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	4217 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4218 }
7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4219
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4221 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4222 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	4223 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	4224 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4226 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	4227 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4228 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4229 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4230 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	4231 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	4232 root->read_mem = read_m68k;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4233 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	4234 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	4235 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	4236 debug_var *var;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4237 switch (current_system->type)
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4238 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4239 case SYSTEM_GENESIS:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4240 case SYSTEM_SEGACD:
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4241 //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	4242 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	4243 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	4244 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	4245 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	4246 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	4247 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	4248 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	4249 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	4250 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	4251 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	4252 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	4253 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	4254 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	4255 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	4256 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	4257 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	4258 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4259 break;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4260 } 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	4261 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	4262 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	4263 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	4264 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	4265 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4266 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	4267 break;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4268 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4269 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	4270 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4271 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	4272 }
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	4273
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	4274 #ifndef NO_Z80
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4275
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4276 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	4277 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4278 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4279 uint32_t address = *out;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4280 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	4281 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4282 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	4283 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4284 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4285 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4286
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4287 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	4288 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4289 z80_context *context = root->cpu_context;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4290 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	4291 if (size == 'w') {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4292 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	4293 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4294 return 1;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4295 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4296
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4298 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4300 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4304 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4306 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	4307 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	4308 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	4309 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	4310 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4316 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4318 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	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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4322 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4324 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	4325 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	4326 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	4327 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	4328 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4330 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4331
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4333 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4335 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	4336 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	4337 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	4338 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	4339 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	4340 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	4341 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	4342 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	4343 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	4344 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4345
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4347 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4348 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	4349 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	4350 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	4351 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	4352 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	4353 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	4354 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	4355 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	4356 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	4357 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	4358 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4359
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4360 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	4361 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4363 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	4364 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	4365 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	4366 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	4367 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4369 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	4370 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	4371 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	4372 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	4373 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	4374 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4377 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4378 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	4379 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	4380 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	4381 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	4382 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	4383 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4384 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	4385 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	4386 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	4387 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	4388 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	4389 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	4390 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4393 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4395 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	4396 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	4397 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	4398 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	4399 } 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	4400 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	4401 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4403 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4406 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4408 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	4409 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	4410 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	4411 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	4412 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4414 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	4415 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	4416 } 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	4417 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	4418 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	4419 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4422 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	4423 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4424 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	4425 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	4426 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	4427 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	4428 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	4429 } 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	4430 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	4431 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4433 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4435 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	4436 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4437 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	4438 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	4439 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	4440 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	4441 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	4442 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4443 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	4444 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	4445 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	4446 } 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	4447 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	4448 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	4449 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4450 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4451
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4453 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4455 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	4456 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4457
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4458 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	4459 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4460 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	4461 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	4462 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	4463 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	4464 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	4465 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4466 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	4467 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4468
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4469 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	4470 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4471 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	4472 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	4473 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4474
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4475 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	4476 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4477 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	4478 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	4479 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	4480 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	4481 return;
2198 0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4482 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4483 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	4484 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4485
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4486 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	4487 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4488 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	4489 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	4490 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4491
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4492 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	4493 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4494 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	4495 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	4496 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4497
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4498 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	4499 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4500 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	4501 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	4502 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4503
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4504 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	4505 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4506 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	4507 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	4508 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4509
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4510 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	4511 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4512 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	4513 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	4514 }
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4515
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4516 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	4517 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4518 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	4519 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	4520 }
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4521
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4522 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	4523 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4524 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	4525 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	4526 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4527 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	4528 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	4529 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	4530 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	4531 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	4532 } 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	4533 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	4534 var->set = z80_sp_set;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4535 } 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	4536 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	4537 var->set = z80_regpair_set;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4538 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4539 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	4540 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	4541 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	4542 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	4543 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	4544 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	4545 {
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4546 d = toupper(c);
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4547 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4548 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	4549 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	4550
b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4551 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	4552 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	4553 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	4554 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	4555 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	4556 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	4557 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	4558 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	4559 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	4560 } 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	4561 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	4562 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	4563 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4564 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	4565 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	4566 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	4567 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	4568 {
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 d = toupper(c);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4570 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types 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 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	4572 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4573 free(name);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4574 }
2362 b6c5a0fa3dfc Refactor debugger a bit. Allow types other than integers to be passed in expressions and stored in arrays. Better namespace support Michael Pavone <pavone@retrodev.com> parents: 2361 diff changeset	4575 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	4576 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	4577 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	4578 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	4579 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	4580 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	4581 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	4582 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	4583 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	4584 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	4585 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	4586 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	4587 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	4588 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	4589 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	4590 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	4591 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	4592 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	4593 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	4594 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	4595 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	4596 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	4597 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	4598 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	4599 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	4600 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	4601 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	4602 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	4603 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	4604 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	4605 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	4606 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	4607 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	4608 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	4609 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	4610 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	4611 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	4612 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4613
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4614 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	4615 {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4616 debug_root *root = find_root(context);
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4617 if (root && !root->commands) {
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4618 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	4619 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	4620 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	4621 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	4622 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	4623 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	4624 //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	4625 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	4626 {
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4627 case SYSTEM_GENESIS:
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4628 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	4629 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	4630 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	4631 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	4632 //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	4633 break;
0dcb9e4dee7f Give SMS debugger a bit more parity to the Genesis one Michael Pavone <pavone@retrodev.com> parents: 2193 diff changeset	4634 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	4635 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	4636 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	4637 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	4638 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	4639 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	4640 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	4641 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	4642 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	4643 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	4644 //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	4645 //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	4646 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4647 root->read_mem = read_z80;
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4648 root->write_mem = write_z80;
2216 4e27c36f947c Add disassemble command to debugger Michael Pavone <pavone@retrodev.com> parents: 2214 diff changeset	4649 root->disasm = create_z80_disasm();
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4650 }
f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4651 return root;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4652 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4653
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4654 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	4655 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4656 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4657 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4658 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	4659 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	4660 init_terminal();
2180 b87658ba3b94 Fix bug in Z80 debugger for SMS mode post-refactor Michael Pavone <pavone@retrodev.com> parents: 2179 diff changeset	4661 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	4662 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	4663 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	4664 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4665 root->address = address;
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4666 //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	4667 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	4668 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4669 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	4670 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4671 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	4672 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4673 return context;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4674 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4675 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4676 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	4677 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4678 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4679 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4680 }
2208 3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4681 int debugging = 1;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4682 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	4683 {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4684 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	4685 }
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4686 if (debugging) {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4687 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	4688 } else {
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4689 return context;
3809a0bd680e Fix a couple of Z80 debugger issues Michael Pavone <pavone@retrodev.com> parents: 2198 diff changeset	4690 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4691 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4692 zremove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4693 }
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	4694 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	4695 if (!pc) {
6b5c92b6205c Enabled Z80 debugger in PBC mode Michael Pavone <pavone@retrodev.com> parents: 1111 diff changeset	4696 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	4697 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4698 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	4699 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	4700 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	4701 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	4702 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	4703 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	4704 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4705 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4706 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4707 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	4708 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	4709 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4710 }
2188 e17d99c96c89 Make blocks an explicitly supported concept in the debugger rather than a one-off for the commands command Michael Pavone <pavone@retrodev.com> parents: 2187 diff changeset	4711
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4712 z80_disasm(&inst, input_buf, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4713 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	4714 debugger_repl(root);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4715 return context;
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4716 }
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4717
548 a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4718 #endif
a3afee2271ce Initial work on the x86-32 target Michael Pavone <pavone@retrodev.com> parents: 525 diff changeset	4719
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	4720 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	4721 {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4722 static char last_cmd[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4723 char input_buf[1024];
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4724 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	4725
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	4726 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	4727
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	4728 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	4729 if (context->system == current_system) {
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4730 genesis_context *gen = context->system;
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4731 vdp_force_update_framebuffer(gen->vdp);
ff32a90260c9 Initial support for using debugger on sub CPU Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	4732 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4733 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	4734 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	4735 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	4736 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4737 //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	4738 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	4739 if (address == root->branch_t) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4740 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	4741 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	4742 remove_breakpoint(context, root->branch_f);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4743 }
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	4744 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	4745 } else if(address == root->branch_f) {
2361 3350b3c8faa8 Initial implementation of VDP register write breakpoints Michael Pavone <pavone@retrodev.com> parents: 2360 diff changeset	4746 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	4747 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	4748 remove_breakpoint(context, root->branch_t);
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4749 }
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	4750 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	4751 }
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	4752
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4753 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	4754 int debugging = 1;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4755 //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	4756 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	4757 if (*this_bp) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4758 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	4759 debug_val condres;
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4760 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	4761 if (!condres.v.u32) {
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4762 return;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4763 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4764 } else {
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4765 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	4766 free_expr((*this_bp)->condition);
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4767 (*this_bp)->condition = NULL;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4768 }
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4769 }
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4770 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	4771 {
2178 f6d5bde4d07f Finish debugger refactor started with expression parser changes Michael Pavone <pavone@retrodev.com> parents: 2177 diff changeset	4772 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	4773 }
5a3ac6093ea2 Add support for executing a list of debugger commands when a breakpoint is hit Michael Pavone <pavone@retrodev.com> parents: 829 diff changeset	4774 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	4775 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	4776 } 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	4777 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	4778 }
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4779 } else {
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4780 remove_breakpoint(context, address);
fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4781 }
2182 2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4782 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	4783 root->after = after;
2d7f8195be3b Add support for conditional breakpoints Michael Pavone <pavone@retrodev.com> parents: 2181 diff changeset	4784 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	4785 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	4786 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	4787 make_format_str(format_str, cur->format);
2183 eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4788 for (int i = 0; i < cur->num_args; i++)
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4789 {
eb2e0e61b1b4 Fix stale values in display Michael Pavone <pavone@retrodev.com> parents: 2182 diff changeset	4790 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	4791 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	4792 }
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	4793 }
2214 7591c67b8d1e Support for loading symbols in debugger for use during name resolution and disassembly Michael Pavone <pavone@retrodev.com> parents: 2208 diff changeset	4794 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	4795 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	4796 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	4797 return;
524 fb39534b6604 Move debugging code outside of main source file Mike Pavone <pavone@retrodev.com> parents: diff changeset	4798 }

Mercurial > repos > blastem

annotate debug.c @ 2380:1b21290358a8