repos/blastem: debug.c annotate

annotate debug.c @ 2194:01ff005b08f6

Very rudimentary support for Game Gear VDP emulation

author	Michael Pavone <pavone@retrodev.com>
date	Sun, 21 Aug 2022 22:29:47 -0700
parents	d00fb9c6a6a2
children	0dcb9e4dee7f

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

Mercurial > repos > blastem

annotate debug.c @ 2194:01ff005b08f6