repos/blastem: debug.c annotate

annotate debug.c @ 2208:3809a0bd680e

Fix a couple of Z80 debugger issues

author	Michael Pavone <pavone@retrodev.com>
date	Sat, 27 Aug 2022 22:02:09 -0700
parents	0dcb9e4dee7f
children	7591c67b8d1e

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

Mercurial > repos > blastem

annotate debug.c @ 2208:3809a0bd680e