qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-12-02 00:52:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/ruamoko/qwaq/builtins/debug.c

731 lines
20 KiB
C
Raw Normal View History

[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
/*
[qwaq] Clean up the qwaq directory Things were getting rather cluttered with everything being qwaq-* and all in one directory. Now most have lost the qwaq- prefix and have been moved into subdirectories (non-recursive make).
2020-03-29 17:34:08 +00:00
debug.c
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
Debugging support
Copyright (C) 2020 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2020/03/24
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <ctype.h>
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "QF/dstring.h"
#include "QF/hash.h"
#include "QF/keys.h"
[qwaq] Add builtin to get a file's full path If the file's base directory cannot be found, the file name is returned as-is.
2020-04-04 03:51:42 +00:00
#include "QF/quakefs.h"
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
#include "QF/sys.h"
[build] Move to non-recursive make There's still some cleanup to do, but everything seems to be working nicely: `make -j` works, `make distcheck` passes. There is probably plenty of bitrot in the package directories (RPM, debian), though. The vc project files have been removed since those versions are way out of date and quakeforge is pretty much dependent on gcc now anyway. Most of the old Makefile.am files are now Makemodule.am. This should allow for new Makefile.am files that allow local building (to be added on an as-needed bases). The current remaining Makefile.am files are for standalone sub-projects.a The installable bins are currently built in the top-level build directory. This may change if the clutter gets to be too much. While this does make a noticeable difference in build times, the main reason for the switch was to take care of the growing dependency issues: now it's possible to build tools for code generation (eg, using qfcc and ruamoko programs for code-gen).
2020-06-21 14:15:17 +00:00
#include "ruamoko/qwaq/qwaq.h"
#include "ruamoko/qwaq/ui/event.h"
#include "ruamoko/qwaq/ui/curses.h"
#include "ruamoko/qwaq/debugger/debug.h"
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
typedef struct qwaq_target_s {
progs_t *pr;
struct qwaq_debug_s *debugger;
int handle;
prdebug_t event;
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
void *param;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
rwcond_t run_cond;
[qwaq] Use an actual condition variable for control I think I wasn't sure at the time whether the simple variable was required for pthread_cond_wait (and friends) to work properly, but it is: the time between the target posting the debug event and the target waiting on the condition variable turns out to sometimes be enough for the debugger to handle the event and signal the target to continue, resulting in the target waiting on a signal that will never come because another debug event will not be sent by the target until AFTER it has exited from the debug handler.
2020-07-03 12:46:09 +00:00
int run_command;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
} qwaq_target_t;
typedef struct qwaq_debug_s {
progs_t *pr;
[qwaq] Move input handling to its own thread As it is now a completely separate sub-system, there is a bit of trouble with mouse handling in that curses must be initialized before input for the mouse to work properly, but the basic scheme seems to be working nicely. I suspect the solution to the init order issue is to make have the curses sub-system initialize the terminal input driver, at least for mouse input (ie, maybe just enable/disable mouse handing).
2021-09-22 07:22:11 +00:00
qwaq_input_resources_t *input; // to communicate with the debugger thread
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
PR_RESMAP (qwaq_target_t) targets;
} qwaq_debug_t;
#define always_inline inline __attribute__((__always_inline__))
static qwaq_target_t *
target_new (qwaq_debug_t *debug)
{
[gamecode] Make PR_RESMAP macros more function-like I never liked that some of the macros needed the type as a parameter (yay typeof and __auto_type) or those that returned a value hid the return statement so they couldn't be used in assignments.
2021-03-21 12:26:36 +00:00
return PR_RESNEW (debug->targets);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static void
target_free (qwaq_debug_t *debug, qwaq_target_t *target)
{
[gamecode] Make PR_RESMAP macros more function-like I never liked that some of the macros needed the type as a parameter (yay typeof and __auto_type) or those that returned a value hid the return statement so they couldn't be used in assignments.
2021-03-21 12:26:36 +00:00
PR_RESFREE (debug->targets, target);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static void
target_reset (qwaq_debug_t *debug)
{
[gamecode] Make PR_RESMAP macros more function-like I never liked that some of the macros needed the type as a parameter (yay typeof and __auto_type) or those that returned a value hid the return statement so they couldn't be used in assignments.
2021-03-21 12:26:36 +00:00
PR_RESRESET (debug->targets);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static inline qwaq_target_t *
target_get (qwaq_debug_t *debug, unsigned index)
{
[gamecode] Make PR_RESMAP macros more function-like I never liked that some of the macros needed the type as a parameter (yay typeof and __auto_type) or those that returned a value hid the return statement so they couldn't be used in assignments.
2021-03-21 12:26:36 +00:00
return PR_RESGET (debug->targets, index);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
static inline int __attribute__((pure))
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
target_index (qwaq_debug_t *debug, qwaq_target_t *target)
{
[gamecode] Make PR_RESMAP macros more function-like I never liked that some of the macros needed the type as a parameter (yay typeof and __auto_type) or those that returned a value hid the return statement so they couldn't be used in assignments.
2021-03-21 12:26:36 +00:00
return PR_RESINDEX (debug->targets, target);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static always_inline qwaq_target_t * __attribute__((pure))
get_target (qwaq_debug_t *debug, const char *name, int handle)
{
qwaq_target_t *target = target_get (debug, handle);
if (!target || !target->debugger) {
PR_RunError (debug->pr, "invalid target passed to %s", name + 4);
}
return target;
}
static void
[gamecode] Add a param pointer to debug_handler I decided I want events for VM enter/exit but enter needs to somehow pass the function which will be executed (even if a builtin). A generic void * param seemed the best idea, which meant the error string could be passed via the param instead of a "global" string in the progs struct.
2020-03-26 02:44:02 +00:00
qwaq_debug_handler (prdebug_t debug_event, void *param, void *data)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
__auto_type target = (qwaq_target_t *) data;
qwaq_debug_t *debug = target->debugger;
qwaq_event_t event = {};
int ret;
target->event = debug_event;
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
target->param = param;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
event.what = qe_debug_event;
event.message.pointer_val = target->handle;
[qwaq] Move input handling to its own thread As it is now a completely separate sub-system, there is a bit of trouble with mouse handling in that curses must be initialized before input for the mouse to work properly, but the basic scheme seems to be working nicely. I suspect the solution to the init order issue is to make have the curses sub-system initialize the terminal input driver, at least for mouse input (ie, maybe just enable/disable mouse handing).
2021-09-22 07:22:11 +00:00
while ((ret = qwaq_add_event (debug->input, &event)) == ETIMEDOUT) {
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
// spin
}
if (ret == EINVAL) {
Sys_Error ("event queue broke");
}
pthread_mutex_lock (&target->run_cond.mut);
[qwaq] Use an actual condition variable for control I think I wasn't sure at the time whether the simple variable was required for pthread_cond_wait (and friends) to work properly, but it is: the time between the target posting the debug event and the target waiting on the condition variable turns out to sometimes be enough for the debugger to handle the event and signal the target to continue, resulting in the target waiting on a signal that will never come because another debug event will not be sent by the target until AFTER it has exited from the debug handler.
2020-07-03 12:46:09 +00:00
while (!target->run_command) {
pthread_cond_wait (&target->run_cond.rcond, &target->run_cond.mut);
}
target->run_command = 0;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
pthread_mutex_unlock (&target->run_cond.mut);
if (debug_event == prd_runerror || debug_event == prd_error) {
[gamecode] Add a param pointer to debug_handler I decided I want events for VM enter/exit but enter needs to somehow pass the function which will be executed (even if a builtin). A generic void * param seemed the best idea, which meant the error string could be passed via the param instead of a "global" string in the progs struct.
2020-03-26 02:44:02 +00:00
pthread_exit (param);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
}
[qwaq] Guard qwaq_debug_data with a pthread cond I should have realized this would be prone to races.
2020-04-04 01:58:53 +00:00
//FIXME need a better way to get this from one thread to the others
pthread_cond_t debug_data_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t debug_data_mutex = PTHREAD_MUTEX_INITIALIZER;
static qwaq_debug_t *qwaq_debug_data;
static int
qwaq_debug_load (progs_t *pr)
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) PR_Resources_Find (pr, "qwaq-debug");
[qwaq] Guard qwaq_debug_data with a pthread cond I should have realized this would be prone to races.
2020-04-04 01:58:53 +00:00
pthread_mutex_lock (&debug_data_mutex);
qwaq_debug_data = debug; // FIXME ? see decl
pthread_cond_broadcast (&debug_data_cond);
pthread_mutex_unlock (&debug_data_mutex);
return 1;
}
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qwaq_debug_clear (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
target_reset (debug);
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qwaq_target_clear (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
qwaq_target_t *target = pr->debug_data;
[qwaq] Create a debugger class Each debugger manages a single target.
2020-03-24 16:07:58 +00:00
if (target) {
target_free (target->debugger, target);
}
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static int
qwaq_target_load (progs_t *pr)
{
[qwaq] Guard qwaq_debug_data with a pthread cond I should have realized this would be prone to races.
2020-04-04 01:58:53 +00:00
pthread_mutex_lock (&debug_data_mutex);
while (!qwaq_debug_data) {
pthread_cond_wait (&debug_data_cond, &debug_data_mutex);
}
pthread_mutex_unlock (&debug_data_mutex);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
qwaq_target_t *target = target_new (qwaq_debug_data);
target->pr = pr;
target->debugger = qwaq_debug_data;
target->handle = target_index (qwaq_debug_data, target);
qwaq_init_cond (&target->run_cond);
[qwaq] Use an actual condition variable for control I think I wasn't sure at the time whether the simple variable was required for pthread_cond_wait (and friends) to work properly, but it is: the time between the target posting the debug event and the target waiting on the condition variable turns out to sometimes be enough for the debugger to handle the event and signal the target to continue, resulting in the target waiting on a signal that will never come because another debug event will not be sent by the target until AFTER it has exited from the debug handler.
2020-07-03 12:46:09 +00:00
target->run_command = 0;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
pr->debug_handler = qwaq_debug_handler;
pr->debug_data = target;
// start tracing immediately so the debugger has a chance to start up
// before the target progs begin running
pr->pr_trace = 1;
pr->pr_trace_depth = -1;
return 1;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_set_trace (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
int state = P_INT (pr, 1);
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
tpr->pr_trace = state;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_set_breakpoint (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
unsigned staddr = P_INT (pr, 1);
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (staddr >= tpr->progs->statements.count) {
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
R_INT (pr) = -1;
return;
}
[qwaq] Implement execute-to-cursor Support for finding the first address associated with a source line was added to the engine, returning 0 if not found. A temporary breakpoint is set and the progs allowed to run free. However, better handling of temporary breakpoitns is needed as currently a "permanent" breakpoint will be cleared without clearing the temporary breakpoing if the permanent breakpoing is hit while execut-to-cursor is running.
2021-06-08 07:54:04 +00:00
int set = (tpr->pr_statements[staddr].op & OP_BREAK) != 0;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
tpr->pr_statements[staddr].op |= OP_BREAK;
[qwaq] Implement execute-to-cursor Support for finding the first address associated with a source line was added to the engine, returning 0 if not found. A temporary breakpoint is set and the progs allowed to run free. However, better handling of temporary breakpoitns is needed as currently a "permanent" breakpoint will be cleared without clearing the temporary breakpoing if the permanent breakpoing is hit while execut-to-cursor is running.
2021-06-08 07:54:04 +00:00
R_INT (pr) = set;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_clear_breakpoint (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
unsigned staddr = P_UINT (pr, 1);
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (staddr >= tpr->progs->statements.count) {
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
R_INT (pr) = -1;
return;
}
tpr->pr_statements[staddr].op &= ~OP_BREAK;
R_INT (pr) = 0;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_set_watchpoint (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
pr_ptr_t offset = P_UINT (pr, 1);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
if (offset >= tpr->globals_size) {
R_INT (pr) = -1;
return;
}
tpr->watch = &tpr->pr_globals[offset];
R_INT (pr) = 0;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_clear_watchpoint (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
tpr->watch = 0;
R_INT (pr) = 0;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_continue (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
pthread_mutex_lock (&target->run_cond.mut);
[qwaq] Use an actual condition variable for control I think I wasn't sure at the time whether the simple variable was required for pthread_cond_wait (and friends) to work properly, but it is: the time between the target posting the debug event and the target waiting on the condition variable turns out to sometimes be enough for the debugger to handle the event and signal the target to continue, resulting in the target waiting on a signal that will never come because another debug event will not be sent by the target until AFTER it has exited from the debug handler.
2020-07-03 12:46:09 +00:00
target->run_command = 1;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
pthread_cond_signal (&target->run_cond.rcond);
pthread_mutex_unlock (&target->run_cond.mut);
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_state (progs_t *pr, void *_res)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
pr_lineno_t *lineno;
pr_auxfunction_t *f;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_string_t file = 0;
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
unsigned line = 0;
unsigned staddr = tpr->pr_xstatement;
[gamecode] Rename func_t to pr_func_t Even more consistency.
2022-01-18 06:32:43 +00:00
pr_func_t func = 0;
[qwaq] Implement more debugger def views Structs and arrays now work (though could be better, eg collapsible).
2021-09-24 16:42:36 +00:00
if (tpr->pr_xfunction) {
func = tpr->pr_xfunction - tpr->function_table;
}
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
lineno = PR_Find_Lineno (tpr, staddr);
if (lineno) {
[qwaq] Create a debugger class Each debugger manages a single target.
2020-03-24 16:07:58 +00:00
f = PR_Get_Lineno_Func (tpr, lineno);
//FIXME file is a permanent string. dynamic would be better
//but they're not merged (and would need refcounting)
file = PR_SetString (pr, PR_Get_Source_File (tpr, lineno));
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
func = f->function;
[qwaq] Create a debugger class Each debugger manages a single target.
2020-03-24 16:07:58 +00:00
line = PR_Get_Lineno_Line (tpr, lineno);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
line += f->source_line;
}
qdb_state_t state = {};
state.staddr = staddr;
state.func = func;
state.file = file;
state.line = line;
R_PACKED (pr, qdb_state_t) = state;
}
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_stack_depth (progs_t *pr, void *_res)
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
R_INT (pr) = tpr->pr_depth;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_stack (progs_t *pr, void *_res)
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
int count = tpr->pr_depth;
R_POINTER (pr) = 0;
if (count > 0) {
size_t size = count * sizeof (qdb_stack_t);
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_string_t stack_block = PR_AllocTempBlock (pr, size);
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
__auto_type stack = (qdb_stack_t *) PR_GetString (pr, stack_block);
for (int i = 0; i < count; i++) {
stack[i].staddr = tpr->pr_stack[i].staddr;
stack[i].func = tpr->pr_stack[i].func - tpr->pr_xfunction;
//XXX temp strings (need access somehow)
}
R_POINTER (pr) = PR_SetPointer (pr, stack);
}
}
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_event (progs_t *pr, void *_res)
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
[qwaq] Fix some incorrect parameter acesses They weren't wrong as such (the data was being accessed correctly anyway, just not ideal as the parameter access was slightly hidden.
2021-05-30 02:14:05 +00:00
__auto_type event = &P_STRUCT (pr, qdb_event_t, 1);
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
memset (event, 0, sizeof (*event));
event->what = target->event;
switch (event->what) {
case prd_subenter:
[gamecode] Rename func_t to pr_func_t Even more consistency.
2022-01-18 06:32:43 +00:00
event->function = *(pr_func_t *) target->param;
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
break;
case prd_runerror:
case prd_error:
[qwaq] Fix a couple of errors in debug Update qdb_get_string's mangling for qfcc's new unsigned int support and fix an incorrect cast of the param pointer passed by prd_runerror that caused a segfault when trying to use the string. Attempting to use qwaq-app (ie, the qc debugger) on Ruamoko ISA progs mostly works, but the defs are decidedly unhappy (due to the base registers).
2022-01-22 17:04:28 +00:00
event->message = PR_SetReturnString (pr, (char *) target->param);
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
break;
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
case prd_begin:
[gamecode] Rename func_t to pr_func_t Even more consistency.
2022-01-18 06:32:43 +00:00
event->function = *(pr_func_t *) target->param;
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
break;
[qwaq] Make debug event data available
2020-04-02 01:44:16 +00:00
case prd_terminate:
event->exit_code = *(int *) target->param;
break;
case prd_trace:
case prd_breakpoint:
case prd_watchpoint:
case prd_subexit:
case prd_none:
break;
}
R_INT (pr) = target->event != prd_none;
}
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_data (progs_t *pr, void *_res)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t srcoff = P_POINTER (pr, 1);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
unsigned length = P_UINT (pr, 2);
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t dstoff = P_POINTER(pr, 3);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
pr_type_t *src = PR_GetPointer(tpr, srcoff);
pr_type_t *dst = PR_GetPointer(pr, dstoff);
if (srcoff >= tpr->globals_size || srcoff + length >= tpr->globals_size) {
R_INT (pr) = -1;
return;
}
if (dstoff >= pr->globals_size || dstoff + length >= pr->globals_size) {
R_INT (pr) = -1;
return;
}
memcpy (dst, src, length * sizeof (pr_type_t));
R_INT (pr) = 0;
}
[qwaq] Add function to get a string from the target
2020-03-26 09:14:20 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_string (progs_t *pr, void *_res)
[qwaq] Add function to get a string from the target
2020-03-26 09:14:20 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add function to get a string from the target
2020-03-26 09:14:20 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_string_t string = P_STRING (pr, 1);
[qwaq] Add function to get a string from the target
2020-03-26 09:14:20 +00:00
R_STRING (pr) = 0;
if (PR_StringValid (tpr, string)) {
RETURN_STRING (pr, PR_GetString (tpr, string));
}
}
[qwaq] Add builtin to get a file's full path If the file's base directory cannot be found, the file name is returned as-is.
2020-04-04 03:51:42 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_file_path (progs_t *pr, void *_res)
[qwaq] Add builtin to get a file's full path If the file's base directory cannot be found, the file name is returned as-is.
2020-04-04 03:51:42 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add builtin to get a file's full path If the file's base directory cannot be found, the file name is returned as-is.
2020-04-04 03:51:42 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *file = P_GSTRING (pr, 1);
const char *basedir = PR_Debug_GetBaseDirectory (tpr, file);
if (basedir) {
size_t baselen = strlen (basedir);
size_t filelen = strlen (file);
char *path = alloca (baselen + filelen + 2);
strcpy (path, basedir);
path[baselen] = '/';
strcpy (path + baselen + 1, file);
path = QFS_CompressPath (path);
RETURN_STRING (pr, path);
free (path);
} else {
R_STRING (pr) = P_STRING (pr, 1);
}
}
[qwaq] Implement more debugger def views Structs and arrays now work (though could be better, eg collapsible).
2021-09-24 16:42:36 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_find_string (progs_t *pr, void *_res)
[qwaq] Implement more debugger def views Structs and arrays now work (though could be better, eg collapsible).
2021-09-24 16:42:36 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Implement more debugger def views Structs and arrays now work (though could be better, eg collapsible).
2021-09-24 16:42:36 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *str = P_GSTRING (pr, 1);
R_INT (pr) = PR_FindString (tpr, str);
}
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_find_global (progs_t *pr, void *_res)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *name = P_GSTRING (pr, 1);
pr_def_t *def = PR_FindGlobal (tpr, name);
if (def) {
R_PACKED (pr, qdb_def_t).type_size = (def->size << 16) | def->type;
R_PACKED (pr, qdb_def_t).offset = def->ofs;
R_PACKED (pr, qdb_def_t).name = def->name;
R_PACKED (pr, qdb_def_t).type_encoding = def->type_encoding;
} else {
memset (&R_PACKED (pr, qdb_def_t), 0, sizeof (qdb_def_t));
}
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_find_field (progs_t *pr, void *_res)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *name = P_GSTRING (pr, 1);
pr_def_t *def = PR_FindField (tpr, name);
if (def) {
R_PACKED (pr, qdb_def_t).type_size = (def->size << 16) | def->type;
R_PACKED (pr, qdb_def_t).offset = def->ofs;
R_PACKED (pr, qdb_def_t).name = def->name;
R_PACKED (pr, qdb_def_t).type_encoding = def->type_encoding;
} else {
memset (&R_PACKED (pr, qdb_def_t), 0, sizeof (qdb_def_t));
}
}
static void
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
return_function (progs_t *pr, dfunction_t *func)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = 0;
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
if (func) {
__auto_type f
= (qdb_function_t *) PR_Zone_Malloc (pr, sizeof (qdb_function_t));
f->staddr = func->first_statement;
[gamecode] Rename parm to param That misspelling bothered me from the very beginning, I'd always have trouble getting the name right when trying to access one of those fields.
2022-01-27 01:55:06 +00:00
f->local_data = func->params_start;
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
f->local_size = func->locals;
f->profile = func->profile;
[gamecode] Remove the wart from def and function names I never liked the leading s_ (though I guess it means one is supposed to interpret the int as a string pointer, but meh).
2021-12-31 06:02:31 +00:00
f->name = func->name;
f->file = func->file;
[gamecode] Rename parm to param That misspelling bothered me from the very beginning, I'd always have trouble getting the name right when trying to access one of those fields.
2022-01-27 01:55:06 +00:00
f->num_params = func->numparams;
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = PR_SetPointer (pr, f);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
}
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_find_function (progs_t *pr, void *_res)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *name = P_GSTRING (pr, 1);
dfunction_t *func = PR_FindFunction (tpr, name);
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
return_function (pr, func);
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_function (progs_t *pr, void *_res)
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
pr_uint_t fnum = P_INT (pr, 1);
dfunction_t *func = tpr->pr_functions + fnum;
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (fnum >= tpr->progs->functions.count) {
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
func = 0;
}
return_function (pr, func);
}
static void
return_auxfunction (progs_t *pr, pr_auxfunction_t *auxfunc)
{
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = 0;
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
if (auxfunc) {
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
__auto_type f
= (qdb_auxfunction_t *) PR_Zone_Malloc (pr,
sizeof (qdb_auxfunction_t));
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
f->function = auxfunc->function;
f->source_line = auxfunc->source_line;
f->line_info = auxfunc->line_info;
f->local_defs = auxfunc->local_defs;
f->num_locals = auxfunc->num_locals;
f->return_type = auxfunc->return_type;
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = PR_SetPointer (pr, f);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
}
}
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_find_auxfunction (progs_t *pr, void *_res)
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *name = P_GSTRING (pr, 1);
dfunction_t *func = PR_FindFunction (tpr, name);
pr_uint_t fnum = func - tpr->pr_functions;
pr_auxfunction_t *auxfunc = PR_Debug_MappedAuxFunction (tpr, fnum);
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (fnum >= tpr->progs->functions.count) {
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
func = 0;
}
return_auxfunction (pr, auxfunc);
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_auxfunction (progs_t *pr, void *_res)
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
pr_uint_t fnum = P_UINT (pr, 1);
pr_auxfunction_t *auxfunc = PR_Debug_MappedAuxFunction (tpr, fnum);
return_auxfunction (pr, auxfunc);
}
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_local_defs (progs_t *pr, void *_res)
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
[qwaq] Add functions to get functions by number
2020-03-26 00:03:44 +00:00
pr_uint_t fnum = P_UINT (pr, 1);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
pr_auxfunction_t *auxfunc = PR_Debug_MappedAuxFunction (tpr, fnum);
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = 0;
[qwaq] Cope with functions that don't have locals In this case, .ctor functions.
2020-04-01 15:51:22 +00:00
if (auxfunc && auxfunc->num_locals) {
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
pr_def_t *defs = PR_Debug_LocalDefs (tpr, auxfunc);
__auto_type qdefs
= (qdb_def_t *) PR_Zone_Malloc (pr,
auxfunc->num_locals * sizeof (qdb_def_t));
for (unsigned i = 0; i < auxfunc->num_locals; i++) {
qdefs[i].type_size = (defs[i].size << 16) | defs[i].type;
qdefs[i].offset = defs[i].ofs;
qdefs[i].name = defs[i].name;
qdefs[i].type_encoding = defs[i].type_encoding;
}
[qwaq] Implement step-over tracing I decided that stopping in between function calls that are on the same line is a good thing as it gives a chance to skip over the first but step into the second.
2020-04-02 08:44:53 +00:00
R_POINTER (pr) = PR_SetPointer (pr, qdefs);
[qwaq] Add support for getting data, defs and functions This will allow for really probing the target progs.
2020-03-25 13:39:17 +00:00
}
}
[qwaq] Implement execute-to-cursor Support for finding the first address associated with a source line was added to the engine, returning 0 if not found. A temporary breakpoint is set and the progs allowed to run free. However, better handling of temporary breakpoitns is needed as currently a "permanent" breakpoint will be cleared without clearing the temporary breakpoing if the permanent breakpoing is hit while execut-to-cursor is running.
2021-06-08 07:54:04 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_source_line_addr (progs_t *pr, void *_res)
[qwaq] Implement execute-to-cursor Support for finding the first address associated with a source line was added to the engine, returning 0 if not found. A temporary breakpoint is set and the progs allowed to run free. However, better handling of temporary breakpoitns is needed as currently a "permanent" breakpoint will be cleared without clearing the temporary breakpoing if the permanent breakpoing is hit while execut-to-cursor is running.
2021-06-08 07:54:04 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short).
2022-01-18 03:11:14 +00:00
pr_ptr_t handle = P_INT (pr, 0);
[qwaq] Implement execute-to-cursor Support for finding the first address associated with a source line was added to the engine, returning 0 if not found. A temporary breakpoint is set and the progs allowed to run free. However, better handling of temporary breakpoitns is needed as currently a "permanent" breakpoint will be cleared without clearing the temporary breakpoing if the permanent breakpoing is hit while execut-to-cursor is running.
2021-06-08 07:54:04 +00:00
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
const char *file = P_GSTRING (pr, 1);
pr_uint_t line = P_UINT (pr, 2);
R_UINT (pr) = PR_FindSourceLineAddr (tpr, file, line);
}
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_has_data_stack (progs_t *pr, void *_res)
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
pr_ptr_t handle = P_INT (pr, 0);
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
R_INT (pr) = tpr->progs->version == PROG_VERSION;
}
static void
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
qdb_get_frame_addr (progs_t *pr, void *_res)
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
{
[gamecode] Pass registered data pointer to builtins This is the bulk of the work for recording the resource pointer with with builtin data. I don't know how much of a difference it makes for most things, but it's probably pretty big for qwaq-curses due to the very high number of calls to the curses builtins. Closes #26
2022-02-14 03:28:38 +00:00
__auto_type debug = (qwaq_debug_t *) _res;
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
pr_ptr_t handle = P_INT (pr, 0);
qwaq_target_t *target = get_target (debug, __FUNCTION__, handle);
progs_t *tpr = target->pr;
R_UINT (pr) = 0;
if (tpr->progs->version == PROG_VERSION) {
if (tpr->pr_depth) {
prstack_t *frame = tpr->pr_stack + tpr->pr_depth - 1;
R_UINT (pr) = frame->stack_ptr;
}
}
}
[gamecode] Provide builtins with information about their parameters This will make it possible for the engine to set up their parameter pointers when running Ruamoko progs. At this stage, it doesn't matter *too* much, except for varargs functions, because no builtin yet takes anything larger than a float quaternion, but it will be critical when double or long vec3 and vec4 values are passed.
2022-01-23 12:54:03 +00:00
#define bi(x,np,params...) {#x, x, -1, np, {params}}
#define p(type) PR_PARAM(type)
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
static builtin_t builtins[] = {
[gamecode] Provide builtins with information about their parameters This will make it possible for the engine to set up their parameter pointers when running Ruamoko progs. At this stage, it doesn't matter *too* much, except for varargs functions, because no builtin yet takes anything larger than a float quaternion, but it will be critical when double or long vec3 and vec4 values are passed.
2022-01-23 12:54:03 +00:00
bi(qdb_set_trace, 2, p(int), p(int)),
bi(qdb_set_breakpoint, 2, p(int), p(uint)),
bi(qdb_clear_breakpoint, 2, p(int), p(uint)),
bi(qdb_set_watchpoint, 2, p(int), p(uint)),
bi(qdb_clear_watchpoint, 1, p(int)),
bi(qdb_continue, 1, p(int)),
bi(qdb_get_state, 1, p(int)),
bi(qdb_get_stack_depth, 1, p(int)),
bi(qdb_get_stack, 1, p(int)),
bi(qdb_get_event, 2, p(int), p(ptr)),
bi(qdb_get_data, 4, p(int), p(uint), p(uint), p(ptr)),
{"qdb_get_string|{tag qdb_target_s=}I", qdb_get_string, -1, 1, {p(uint)}},
{"qdb_get_string|{tag qdb_target_s=}*", qdb_get_string, -1, 1, {p(string)}},
bi(qdb_get_file_path, 2, p(int), p(string)),
bi(qdb_find_string, 2, p(int), p(string)),
bi(qdb_find_global, 2, p(int), p(string)),
bi(qdb_find_field, 2, p(int), p(string)),
bi(qdb_find_function, 2, p(int), p(string)),
bi(qdb_get_function, 2, p(int), p(uint)),
bi(qdb_find_auxfunction, 2, p(int), p(string)),
bi(qdb_get_auxfunction, 2, p(int), p(uint)),
bi(qdb_get_local_defs, 2, p(int), p(uint)),
bi(qdb_get_source_line_addr, 3, p(int), p(string), p(uint)),
[qwaq] Fetch Ruamoko progs locals from the stack frame Now that the data is fetched from the correct location, the locals view is useful again :). However, there seems to be a problem with array views: not sure they're showing the correct data as I was getting unexpected values in the display but normal vars seem to be ok.
2022-02-12 01:19:45 +00:00
bi(qdb_has_data_stack, 1, p(int)),
bi(qdb_get_frame_addr, 1, p(int)),
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
{}
};
void
QWAQ_Debug_Init (progs_t *pr)
{
qwaq_debug_t *debug = calloc (sizeof (*debug), 1);
[qwaq] Guard qwaq_debug_data with a pthread cond I should have realized this would be prone to races.
2020-04-04 01:58:53 +00:00
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
debug->pr = pr;
[qwaq] Move input handling to its own thread As it is now a completely separate sub-system, there is a bit of trouble with mouse handling in that curses must be initialized before input for the mouse to work properly, but the basic scheme seems to be working nicely. I suspect the solution to the init order issue is to make have the curses sub-system initialize the terminal input driver, at least for mouse input (ie, maybe just enable/disable mouse handing).
2021-09-22 07:22:11 +00:00
debug->input = PR_Resources_Find (pr, "input");
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
[qwaq] Guard qwaq_debug_data with a pthread cond I should have realized this would be prone to races.
2020-04-04 01:58:53 +00:00
PR_AddLoadFunc (pr, qwaq_debug_load);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
PR_Resources_Register (pr, "qwaq-debug", debug, qwaq_debug_clear);
[gamecode] Add a data pointer passed to builtin functions This is part of the work for #26 (Record resource pointer with builtin function data). Currently, the data pointer gets as far as the per-instance VM function table (I don't feel like tackling the job of converting all the builtin functions tonight). All the builtin modules that register a resources data block pass that block on to PR_RegisterBuiltins.
2022-01-23 15:20:05 +00:00
PR_RegisterBuiltins (pr, builtins, debug);
[qwaq] Add initial qwaq debugger system It's not hooked up yet, and only very basic functionality is implemented, but I think this approach will work.
2020-03-24 10:52:35 +00:00
}
void
QWAQ_DebugTarget_Init (progs_t *pr)
{
PR_AddLoadFunc (pr, qwaq_target_load);
PR_Resources_Register (pr, "qwaq-target", 0, qwaq_target_clear);
}
Reference in a new issue Copy permalink