qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 06:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/gamecode/pr_load.c

572 lines
16 KiB
C
Raw Normal View History

break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
/*
pr_edict.c
entity dictionary
Copyright (C) 1996-1997 Id Software, Inc.
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
re-arrange things so __attribute__ and __builtin_expect are properly autoconfiscated so rcsid will continue to work with gcc 3.3
2003-01-15 15:31:36 +00:00
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include "QF/crc.h"
#include "QF/cvar.h"
the beginnings of a jihad against buffer overflows
2003-05-08 23:24:02 +00:00
#include "QF/dstring.h"
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
#include "QF/hash.h"
Ensure edict_size is never 0. Avoids division by / in NUM_FOR_EDICT
2012-05-06 12:35:42 +00:00
#include "QF/mathlib.h"
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
#include "QF/progs.h"
#include "QF/qendian.h"
go back to using QFile, quakeio.h and quakefs.h
2002-08-27 07:16:28 +00:00
#include "QF/quakefs.h"
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
#include "QF/sys.h"
#include "QF/zone.h"
[gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so).
2022-02-05 05:07:45 +00:00
#include "QF/progs/pr_type.h"
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
#include "compat.h"
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
VISIBLE int pr_boundscheck;
static cvar_t pr_boundscheck_cvar = {
.name = "pr_boundscheck",
.description =
"Server progs bounds checking",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &pr_boundscheck },
};
int pr_deadbeef_ents;
static cvar_t pr_deadbeef_ents_cvar = {
.name = "pr_deadbeef_ents",
.description =
"set to clear unallocated memory to 0xdeadbeef",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &pr_deadbeef_ents },
};
int pr_deadbeef_locals;
static cvar_t pr_deadbeef_locals_cvar = {
.name = "pr_deadbeef_locals",
.description =
"set to clear uninitialized local vars to 0xdeadbeef",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &pr_deadbeef_locals },
};
int pr_faultchecks;
static cvar_t pr_faultchecks_cvar = {
.name = "pr_faultchecks",
.description =
"capture and handle division by 0 in progs",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &pr_faultchecks },
};
sys.[ch]: handle SIGFPE and allow the registered signal handler to do recovery rather than bail progs.h, pr_exec.c, pr_load.c: if pr_faultchecks is 1 (0 is default), handle division by 0 gracefully by loading the maximum representable number into the answer Closes: #58 the rest: kill the SIGFPE stuff
2002-11-13 19:26:44 +00:00
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
static const char *
Make hash tables more const correct. And clean up the resulting mess :/
2012-07-18 13:34:37 +00:00
function_get_key (const void *f, void *_pr)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
{
progs_t *pr = (progs_t*)_pr;
dfunction_t *func = (dfunction_t*)f;
[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
return PR_GetString (pr, func->name);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
static const char *
Make hash tables more const correct. And clean up the resulting mess :/
2012-07-18 13:34:37 +00:00
var_get_key (const void *d, void *_pr)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
{
progs_t *pr = (progs_t*)_pr;
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
pr_def_t *def = (pr_def_t*)d;
return PR_GetString (pr, def->name);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
[gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so).
2022-02-05 05:07:45 +00:00
static const char *
type_get_key (const void *t, void *_pr)
{
progs_t *pr = (progs_t *) _pr;
__auto_type type = (qfot_type_t *) t;
return PR_GetString (pr, type->encoding);
}
make pr_source_path a ; separated list of dirs and make it controllable in qfprogs
2003-03-12 22:31:44 +00:00
static void
file_error (progs_t *pr, const char *path)
{
Sys_Printf ("failed to load %s\n", path);
}
qfprogs can now read the debug data
2002-06-11 17:24:37 +00:00
static void *
Make pr.load_file 'return' the file size
2020-02-21 12:17:28 +00:00
load_file (progs_t *pr, const char *path, off_t *size)
qfprogs can now read the debug data
2002-06-11 17:24:37 +00:00
{
Make pr.load_file 'return' the file size
2020-02-21 12:17:28 +00:00
void *data = QFS_LoadHunkFile (QFS_FOpenFile (path));
*size = qfs_filesize;
return data;
qfprogs can now read the debug data
2002-06-11 17:24:37 +00:00
}
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
static void *
allocate_progs_mem (progs_t *pr, int size)
{
[util] Make hunk (optionally) thread-safe For now, the functions check for a null hunk pointer and use the global hunk (initialized via Memory_Init) if necessary. However, Hunk_Init is available (and used by Memory_Init) to create a hunk from any arbitrary memory block. So long as that block is 64-byte aligned, allocations within the hunk will remain 64-byte aligned.
2021-07-28 06:01:45 +00:00
return Hunk_AllocName (0, size, pr->progs_name);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
}
basic resource management system for the VM
2002-01-30 06:21:20 +00:00
static void
free_progs_mem (progs_t *pr, void *mem)
{
}
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
static int
[gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs.
2022-01-26 07:55:14 +00:00
align_size (int size, int align)
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
{
[gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs.
2022-01-26 07:55:14 +00:00
size += align - 1;
size &= ~(align - 1);
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
return size;
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
Simplify the call to PR_LoadProgsFile. I've decided that setting pr.max_edicts and pr.zone_size as part of the local progs initialization rather than in PR_LoadProgsFile makes more sense. For one, it is unlikely for the limits to change every time progs is reloaded. Also, they seem to be a property of the VM rather than the progs. However, there is nothing stopping the caller from updating max_edicts and zone_size every call.
2018-10-11 01:06:48 +00:00
PR_LoadProgsFile (progs_t *pr, QFile *file, int size)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
{
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
size_t i;
o all progs strings are now stored in progs memory o temporary strings automaticly get freed when the function they're created in (results of str + str and most strings returned from builtins). a way to keep temp strings will be provided later o fix up qwaq to test the temp strings
2004-01-03 08:43:57 +00:00
int mem_size;
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
int offset_tweak;
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
dprograms_t progs;
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
byte *base;
[gamecode] Fix bad progs strings intialization The merge with the improvements I made while hacking on csqc (still undecided as to whether to continue that project) resulted in the size of the progs string area getting mangled when no heap was allocated for the progs due to a null zone pointer being used in some pointer arithmetic. Fixes random(!!!) invalid string error in qfprogs.
2021-03-29 08:31:17 +00:00
byte *heap;
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
ddef_t *global_ddefs;
ddef_t *field_ddefs;
[gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs.
2022-01-26 07:55:14 +00:00
// absolute minimum alignment is 4 bytes
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
int edict_alignment = __alignof__(pr_lvec4_t);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
plug a memory leak the progs memory was never being freed between maps because the pointer was being cleared at the start of PR_LoadProgsFile.
2010-01-13 06:27:19 +00:00
if (!pr->file_error)
pr->file_error = file_error;
if (!pr->load_file)
pr->load_file = load_file;
if (!pr->allocate_progs_mem)
pr->allocate_progs_mem = allocate_progs_mem;
if (!pr->free_progs_mem)
pr->free_progs_mem = free_progs_mem;
PR_Resources_Clear (pr);
if (pr->progs)
pr->free_progs_mem (pr, pr->progs);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
pr->progs = 0;
plug a memory leak the progs memory was never being freed between maps because the pointer was being cleared at the start of PR_LoadProgsFile.
2010-01-13 06:27:19 +00:00
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
if (Qread (file, &progs, sizeof (progs)) != sizeof (progs))
fix up a couple of error cases (and catch them!)
2003-01-29 20:32:44 +00:00
PR_Error (pr, "error reading header");
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
// store prog crc
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
pr->crc = CRC_Block ((byte*)&progs, sizeof (progs));
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
pr->denorm_found = 0;
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
// byte swap the header
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
for (i = 0; i < sizeof (progs) / 4; i++)
((int *) &progs)[i] = LittleLong (((int *) &progs)[i]);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
if (progs.version != PROG_VERSION
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
&& progs.version != PROG_V6P_VERSION
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
&& progs.version != PROG_ID_VERSION) {
if (progs.version < 0x00fff000) {
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
PR_Error (pr, "%s has unrecognised version number (%u)",
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
pr->progs_name, progs.version);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
} else {
PR_Error (pr,
"%s has unrecognised version number (%02x.%03x.%03x)"
" [%02x.%03x.%03x expected]",
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
pr->progs_name,
progs.version >> 24,
(progs.version >> 12) & 0xfff,
progs.version & 0xfff,
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PROG_VERSION >> 24,
(PROG_VERSION >> 12) & 0xfff,
PROG_VERSION & 0xfff);
}
}
[gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs.
2022-01-26 07:55:14 +00:00
if (progs.version == PROG_VERSION) {
// ensure SIMD types can be aligned (qfcc will align them within
// the progs memory map, so the engine needs to ensure the progs memory
// is aligned)
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
edict_alignment = __alignof__(pr_lvec4_t);
[gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs.
2022-01-26 07:55:14 +00:00
}
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
// edict size is in words
edict_alignment /= 4;
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
// Some compilers (eg, FTE) put extra data between the header and the
// strings section. What's worse, they de-align the data.
[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
offset_tweak = progs.strings.offset % sizeof (pr_int_t);
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
offset_tweak = (sizeof (pr_int_t) - offset_tweak) % sizeof (pr_int_t);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
// size of progs themselves
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
pr->progs_size = size + offset_tweak;
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_dev, "Programs occupy %iK.\n", size / 1024);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
pr->progs_size = align_size (pr->progs_size, 64);
pr->zone_size = align_size (pr->zone_size, 64);
pr->stack_size = align_size (pr->stack_size, 64);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
Rewrite edict access. The server edict arrays are now stored outside of progs memory, only the entity data itself (ie data accessible to progs via ent.fld) is stored in progs memory. Many of the changes were due to code accessing edicts and entity fields directly rather than through the provided macros.
2013-01-17 05:11:54 +00:00
// size of edict asked for by progs, but at least 1
pr->pr_edict_size = max (1, progs.entityfields);
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
pr->pr_edict_size = align_size (pr->pr_edict_size, edict_alignment);
Merge master into csqc-improvements That was a mess
2021-03-25 13:01:31 +00:00
pr->pr_edict_area_size = pr->max_edicts * pr->pr_edict_size;
[gamecode] Use 64 byte alignment for most of progs memory Only edicts themselves get a smaller alignment (4, 8 or 32 bytes, depending on hardware and progs version). I didn't want to waste too much memory on edict alignment for progs that don't need any better than void *, but the zone really wants 64 bytes, and the stack might as well have 64 bytes as well. Fixes a segfault when running v6 progs in a clang build (clang got really agressive with simd in zone.c).
2022-03-30 17:51:05 +00:00
pr->pr_edict_area_size = align_size (pr->pr_edict_area_size, 64);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
Rewrite edict access. The server edict arrays are now stored outside of progs memory, only the entity data itself (ie data accessible to progs via ent.fld) is stored in progs memory. Many of the changes were due to code accessing edicts and entity fields directly rather than through the provided macros.
2013-01-17 05:11:54 +00:00
mem_size = pr->pr_edict_area_size * sizeof (pr_type_t);
Merge master into csqc-improvements That was a mess
2021-03-25 13:01:31 +00:00
mem_size += pr->progs_size + pr->zone_size + pr->stack_size;
[gamecode] Move return buffer to end of progs memory map With the return buffer in progs_t, it could not be addressed by the progs on 64-bit machines (this was intentional, actually), but in order to get obj_msg_sendv working properly, I needed a way to "bounce" the return address of a calling function to the called function. The cleanest solution I could think of was to add a mode to the with instruction allowing the return pointer to be loaded into a register and then calling the function with a 0 offset for the return value but using the relevant register (next few commits). Testing promptly segfaulted due to the 64-bit offset not fitting into a 32-bit value.
2022-02-05 09:37:23 +00:00
// space for return buffer
mem_size += PR_MAX_RETURN * sizeof (pr_type_t);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
// +1 for a nul terminator
o all progs strings are now stored in progs memory o temporary strings automaticly get freed when the function they're created in (results of str + str and most strings returned from builtins). a way to keep temp strings will be provided later o fix up qwaq to test the temp strings
2004-01-03 08:43:57 +00:00
pr->progs = pr->allocate_progs_mem (pr, mem_size + 1);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
if (!pr->progs)
return;
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
// Place a nul at the end of progs memory to ensure any unterminated
// strings within progs memory don't run off the end.
o all progs strings are now stored in progs memory o temporary strings automaticly get freed when the function they're created in (results of str + str and most strings returned from builtins). a way to keep temp strings will be provided later o fix up qwaq to test the temp strings
2004-01-03 08:43:57 +00:00
((byte *) pr->progs)[mem_size] = 0;
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
memcpy (pr->progs, &progs, sizeof (progs));
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
base = (byte *) (pr->progs + 1) + offset_tweak;
Qread (file, base, size - sizeof (progs));
CRC_ProcessBlock (base, &pr->crc, size - sizeof (progs));
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
Rewrite edict access. The server edict arrays are now stored outside of progs memory, only the entity data itself (ie data accessible to progs via ent.fld) is stored in progs memory. Many of the changes were due to code accessing edicts and entity fields directly rather than through the provided macros.
2013-01-17 05:11:54 +00:00
pr->pr_edict_area = (pr_type_t *)((byte *) pr->progs + pr->progs_size);
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Fix bad progs strings intialization The merge with the improvements I made while hacking on csqc (still undecided as to whether to continue that project) resulted in the size of the progs string area getting mangled when no heap was allocated for the progs due to a null zone pointer being used in some pointer arithmetic. Fixes random(!!!) invalid string error in qfprogs.
2021-03-29 08:31:17 +00:00
base -= sizeof (progs); // offsets are from file start
heap = (byte *) &pr->pr_edict_area[pr->pr_edict_area_size];
Ensure progs zone is always set on load
2020-02-24 15:25:24 +00:00
pr->zone = 0;
Cleaner handling of zone_size/zone.
2018-10-11 01:22:10 +00:00
if (pr->zone_size) {
//FIXME zone_size needs to be at least as big as memzone_t, but
//memzone_t is opaque so its size is unknown
[gamecode] Fix bad progs strings intialization The merge with the improvements I made while hacking on csqc (still undecided as to whether to continue that project) resulted in the size of the progs string area getting mangled when no heap was allocated for the progs due to a null zone pointer being used in some pointer arithmetic. Fixes random(!!!) invalid string error in qfprogs.
2021-03-29 08:31:17 +00:00
pr->zone = (memzone_t *) heap;
Cleaner handling of zone_size/zone.
2018-10-11 01:22:10 +00:00
}
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
[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
pr->pr_functions = (dfunction_t *) (base + pr->progs->functions.offset);
pr->pr_strings = (char *) base + pr->progs->strings.offset;
[gamecode] Fix bad progs strings intialization The merge with the improvements I made while hacking on csqc (still undecided as to whether to continue that project) resulted in the size of the progs string area getting mangled when no heap was allocated for the progs due to a null zone pointer being used in some pointer arithmetic. Fixes random(!!!) invalid string error in qfprogs.
2021-03-29 08:31:17 +00:00
pr->pr_stringsize = (heap - base) + pr->zone_size;
[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
global_ddefs = (ddef_t *) (base + pr->progs->globaldefs.offset);
field_ddefs = (ddef_t *) (base + pr->progs->fielddefs.offset);
pr->pr_statements = (dstatement_t *) (base + pr->progs->statements.offset);
Ensure the the progs data is aligned. Some QuakeC compilers (eg, FTE) insert a data chunk between the progs header and the rest of the progs data. Unfortunately, FTE does not maintain the assumed 32-bit alignment.
2010-11-20 00:02:56 +00:00
[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
pr->pr_globals = (pr_type_t *) (base + pr->progs->globals.offset);
Merge master into csqc-improvements That was a mess
2021-03-25 13:01:31 +00:00
pr->stack = (pr_type_t *) ((byte *) pr->zone + pr->zone_size);
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
pr->stack_bottom = pr->stack - pr->pr_globals;
pr->globals_size = (pr_type_t *) ((byte *) pr->stack + pr->stack_size)
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
- pr->pr_globals;
[gamecode] Initialize .stack if it's available And implement bounds checks for adjstk.
2022-01-21 11:33:15 +00:00
if (pr->globals.stack && pr->stack_bottom) {
*pr->globals.stack = pr->globals_size;
}
[gamecode] Move return buffer to end of progs memory map With the return buffer in progs_t, it could not be addressed by the progs on 64-bit machines (this was intentional, actually), but in order to get obj_msg_sendv working properly, I needed a way to "bounce" the return address of a calling function to the called function. The cleanest solution I could think of was to add a mode to the with instruction allowing the return pointer to be loaded into a register and then calling the function with a 0 offset for the return value but using the relevant register (next few commits). Testing promptly segfaulted due to the 64-bit offset not fitting into a 32-bit value.
2022-02-05 09:37:23 +00:00
pr->pr_return_buffer = pr->pr_globals + pr->globals_size;
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
Cleaner handling of zone_size/zone.
2018-10-11 01:22:10 +00:00
if (pr->zone) {
Make the offset in zone dumps more useful.
2011-03-08 13:44:56 +00:00
PR_Zone_Init (pr);
Cleaner handling of zone_size/zone.
2018-10-11 01:22:10 +00:00
}
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
[gamecode] Create hash tables in PR_Init This makes much more sense than in PR_LoadProgsFile (and simplifies the latter, too).
2021-12-26 11:33:37 +00:00
Hash_FlushTable (pr->function_hash);
Hash_FlushTable (pr->global_hash);
Hash_FlushTable (pr->field_hash);
[gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so).
2022-02-05 05:07:45 +00:00
Hash_FlushTable (pr->type_hash);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
// byte swap the lumps
[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
for (i = 0; i < pr->progs->statements.count; i++) {
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
pr->pr_statements[i].op = LittleShort (pr->pr_statements[i].op);
pr->pr_statements[i].a = LittleShort (pr->pr_statements[i].a);
pr->pr_statements[i].b = LittleShort (pr->pr_statements[i].b);
pr->pr_statements[i].c = LittleShort (pr->pr_statements[i].c);
}
[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
for (i = 0; i < pr->progs->functions.count; i++) {
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
pr->pr_functions[i].first_statement =
LittleLong (pr->pr_functions[i].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
pr->pr_functions[i].params_start =
LittleLong (pr->pr_functions[i].params_start);
[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
pr->pr_functions[i].name = LittleLong (pr->pr_functions[i].name);
pr->pr_functions[i].file = LittleLong (pr->pr_functions[i].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
pr->pr_functions[i].numparams =
LittleLong (pr->pr_functions[i].numparams);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
pr->pr_functions[i].locals = LittleLong (pr->pr_functions[i].locals);
[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
if (pr->pr_functions[i].name)
Allow reconstructed builtins to be found by name. Certain versions of qcc (fteqcc comes to mind :P) strip the names from builtin functions. This breaks saved games that happen to have a builtin function in a saved function variable. The earlier builtin name reconstruction patch happened to fix the writing of save games for such progs, and this one fixes the reading.
2012-07-20 07:17:26 +00:00
Hash_Add (pr->function_hash, &pr->pr_functions[i]);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
if (pr->pr_globaldefs) {
free (pr->pr_globaldefs);
}
[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
pr->pr_globaldefs = calloc (pr->progs->globaldefs.count, sizeof (pr_def_t));
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
[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
for (i = 0; i < pr->progs->globaldefs.count; i++) {
Do lazy computation of def sizes from type encodings The size is calculated when needed and cached.
2020-02-23 14:29:58 +00:00
pr_ushort_t safe_type = global_ddefs[i].type & ~DEF_SAVEGLOBAL;
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
global_ddefs[i].type = LittleShort (global_ddefs[i].type);
global_ddefs[i].ofs = LittleShort (global_ddefs[i].ofs);
[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
global_ddefs[i].name = LittleLong (global_ddefs[i].name);
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
pr->pr_globaldefs[i].type = global_ddefs[i].type;
Do lazy computation of def sizes from type encodings The size is calculated when needed and cached.
2020-02-23 14:29:58 +00:00
pr->pr_globaldefs[i].size = pr_type_size[safe_type];
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
pr->pr_globaldefs[i].ofs = global_ddefs[i].ofs;
[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
pr->pr_globaldefs[i].name = global_ddefs[i].name;
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
Hash_Add (pr->global_hash, &pr->pr_globaldefs[i]);
}
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
if (pr->pr_fielddefs) {
free (pr->pr_fielddefs);
}
[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
pr->pr_fielddefs = calloc (pr->progs->fielddefs.count, sizeof (pr_def_t));
for (i = 0; i < pr->progs->fielddefs.count; i++) {
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
field_ddefs[i].type = LittleShort (field_ddefs[i].type);
if (field_ddefs[i].type & DEF_SAVEGLOBAL)
PR_Error (pr, "PR_LoadProgs: DEF_SAVEGLOBAL on field def %zd", i);
field_ddefs[i].ofs = LittleShort (field_ddefs[i].ofs);
[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
field_ddefs[i].name = LittleLong (field_ddefs[i].name);
Remove reference to ddef_t from progs.h This cleans up some horrible names and redundant fields that were a result of the transition to pr_def_t
2020-02-22 13:44:08 +00:00
pr->pr_fielddefs[i].type = field_ddefs[i].type;
pr->pr_fielddefs[i].ofs = field_ddefs[i].ofs;
[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
pr->pr_fielddefs[i].name = field_ddefs[i].name;
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
Hash_Add (pr->field_hash, &pr->pr_fielddefs[i]);
}
[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
for (i = 0; i < pr->progs->globals.count; i++)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
((int *) pr->pr_globals)[i] = LittleLong (((int *) pr->pr_globals)[i]);
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
[gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so).
2022-02-05 05:07:45 +00:00
pr_def_t *types_def = PR_FindGlobal (pr, ".type_encodings");
if (types_def) {
__auto_type encodings = &G_STRUCT (pr, qfot_type_encodings_t,
types_def->ofs);
pr->type_encodings = encodings->types;
qfot_type_t *type;
for (pr_ptr_t type_ptr = 4; type_ptr < encodings->size;
type_ptr += type->size) {
type = &G_STRUCT (pr, qfot_type_t, pr->type_encodings + type_ptr);
Hash_Add (pr->type_hash, type);
}
} else {
pr->type_encodings = 0;
}
pr_def_t *xdefs_def = PR_FindGlobal (pr, ".xdefs");
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
if (xdefs_def) {
pr_xdefs_t *xdefs = &G_STRUCT (pr, pr_xdefs_t, xdefs_def->ofs);
xdef_t *xdef = &G_STRUCT (pr, xdef_t, xdefs->xdefs);
pr_def_t *def;
[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
for (def = pr->pr_globaldefs, i = 0; i < pr->progs->globaldefs.count;
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
i++, xdef++, def++) {
def->ofs = xdef->ofs;
def->type_encoding = xdef->type;
}
[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
for (def = pr->pr_fielddefs, i = 0; i < pr->progs->fielddefs.count;
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
i++, xdef++, def++) {
def->ofs = xdef->ofs;
def->type_encoding = xdef->type;
}
[gamecode] Set legacy progs def sizes from type Legacy progs do not have the extended defs data (and usually won't have anything more complicated than a vector), so use the basic type size for the def size. Fixes broken edict prints.
2021-04-25 03:20:32 +00:00
} else {
pr_def_t *def;
[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
for (def = pr->pr_globaldefs, i = 0; i < pr->progs->globaldefs.count;
[gamecode] Set legacy progs def sizes from type Legacy progs do not have the extended defs data (and usually won't have anything more complicated than a vector), so use the basic type size for the def size. Fixes broken edict prints.
2021-04-25 03:20:32 +00:00
i++, def++) {
[gamecode] Make def type when indexing size Fixes #12 However, this is a bit of a band-aid in that the code for global defs seems redundant (there is very similar code a little above that is always executed) and the code for field defs should probably be executed unconditionally: I suspect the problem fixed by d5454faeb76940253c78ed108e2e0647dfb04af7 still shows with game coded compiled with recent versions of the compiler, I just haven't tested any.
2021-06-13 13:13:47 +00:00
def->size = pr_type_size[def->type & ~DEF_SAVEGLOBAL];
[gamecode] Set legacy progs def sizes from type Legacy progs do not have the extended defs data (and usually won't have anything more complicated than a vector), so use the basic type size for the def size. Fixes broken edict prints.
2021-04-25 03:20:32 +00:00
}
[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
for (def = pr->pr_fielddefs, i = 0; i < pr->progs->fielddefs.count;
[gamecode] Set legacy progs def sizes from type Legacy progs do not have the extended defs data (and usually won't have anything more complicated than a vector), so use the basic type size for the def size. Fixes broken edict prints.
2021-04-25 03:20:32 +00:00
i++, def++) {
[gamecode] Make def type when indexing size Fixes #12 However, this is a bit of a band-aid in that the code for global defs seems redundant (there is very similar code a little above that is always executed) and the code for field defs should probably be executed unconditionally: I suspect the problem fixed by d5454faeb76940253c78ed108e2e0647dfb04af7 still shows with game coded compiled with recent versions of the compiler, I just haven't tested any.
2021-06-13 13:13:47 +00:00
def->size = pr_type_size[def->type & ~DEF_SAVEGLOBAL];
[gamecode] Set legacy progs def sizes from type Legacy progs do not have the extended defs data (and usually won't have anything more complicated than a vector), so use the basic type size for the def size. Fixes broken edict prints.
2021-04-25 03:20:32 +00:00
}
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
}
Ensure execution state is initialized on progs load
2020-02-25 06:19:21 +00:00
pr->pr_trace = 0;
pr->pr_trace_depth = 0;
pr->pr_xfunction = 0;
pr->pr_xstatement = 0;
pr->pr_depth = 0;
pr->localstack_used = 0;
Improve handling of pr_argc It is now set to 0 when progs are loaded and every time PR_ExecuteProgram() returns. This takes care of the default case, but when setting parameters, pr_argc needs to be set correctly in case a vararg function is called.
2020-02-25 08:28:32 +00:00
pr->pr_argc = 0;
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
PR_AddLoadFunc (progs_t *pr, int (*func)(progs_t *))
{
if (pr->num_load_funcs == pr->max_load_funcs) {
int n;
pr->max_load_funcs += 8;
n = pr->max_load_funcs;
pr->load_funcs = realloc (pr->load_funcs,
n * sizeof (pr_load_func_t *));
SYS_CHECKMEM (pr->load_funcs);
}
pr->load_funcs[pr->num_load_funcs++] = func;
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
PR_AddLoadFinishFunc (progs_t *pr, int (*func)(progs_t *))
{
if (pr->num_load_finish_funcs == pr->max_load_finish_funcs) {
int n;
pr->max_load_finish_funcs += 8;
n = pr->max_load_finish_funcs;
pr->load_finish_funcs = realloc (pr->load_finish_funcs,
n * sizeof (pr_load_func_t *));
SYS_CHECKMEM (pr->load_finish_funcs);
}
pr->load_finish_funcs[pr->num_load_finish_funcs++] = func;
}
static int
pr_run_ctors (progs_t *pr)
{
Make a bunch of count things positive-only This fixes a pile of FIXMEs, because some things should never be negative.
2020-02-25 12:23:13 +00:00
pr_uint_t fnum;
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
dfunction_t *func;
[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
for (fnum = 0; fnum < pr->progs->functions.count; fnum++) {
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
func = pr->pr_functions + fnum;
[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
if (strequal (PR_GetString (pr, func->name), ".ctor"))
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
PR_ExecuteProgram (pr, fnum);
}
return 1;
}
first step to making qfdefs redundant. "standard" progs now get resolved staticly rather than looking up the defs. "broken" progs should now work.
2004-01-21 08:09:47 +00:00
static int (*load_funcs_1[])(progs_t *) = {
PR_LoadStrings,
Force builtin function descriptors to have a name. That is, the descriptors loaded from the progs file. Some compilers (eg, fteqcc :P) strip builtin names from the progs, which makes debugging difficult.
2012-07-13 01:22:25 +00:00
PR_RelocateBuiltins,
first step to making qfdefs redundant. "standard" progs now get resolved staticly rather than looking up the defs. "broken" progs should now work.
2004-01-21 08:09:47 +00:00
PR_LoadDebug,
0,
};
static int (*load_funcs_2[])(progs_t *) = {
PR_ResolveGlobals,
PR_Check_Opcodes,
0,
};
static int
run_load_funcs (progs_t *pr, int (**load_funcs)(progs_t *))
{
int (**lf)(progs_t *);
for (lf = load_funcs; *lf; lf++)
if (!(*lf)(pr))
return 0;
return 1;
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE int
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
PR_RunLoadFuncs (progs_t *pr)
{
int i;
first step to making qfdefs redundant. "standard" progs now get resolved staticly rather than looking up the defs. "broken" progs should now work.
2004-01-21 08:09:47 +00:00
memset (&pr->globals, 0, sizeof (pr->globals));
pr->fields.nextthink = -1;
pr->fields.frame = -1;
pr->fields.think = -1;
pr->fields.this = -1;
check return value... prevents segfault in menu code if menu.dat has issues
2004-02-07 00:04:00 +00:00
if (!run_load_funcs(pr, load_funcs_1))
return 0;
first step to making qfdefs redundant. "standard" progs now get resolved staticly rather than looking up the defs. "broken" progs should now work.
2004-01-21 08:09:47 +00:00
if (pr->resolve)
if (!pr->resolve (pr))
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
return 0;
check return value... prevents segfault in menu code if menu.dat has issues
2004-02-07 00:04:00 +00:00
if (!run_load_funcs(pr, load_funcs_2))
return 0;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
for (i = 0; i < pr->num_load_funcs; i++)
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
if (!pr->load_funcs[i] (pr))
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
return 0;
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
[gamecode] Delay .ctor calls if debugging This allows a debugger to do any symbol lookups and other preparations between loading progs and the first code execution. .ctors are called as per normal if debug_handler is not set.
2020-04-02 08:28:37 +00:00
return 1;
}
VISIBLE int
PR_RunPostLoadFuncs (progs_t *pr)
{
move the OO runtime support code from libQFgamecode to libQFruamoko where it really belongs :)
2004-01-16 08:02:31 +00:00
if (!pr_run_ctors (pr))
return 0;
while (pr->num_load_finish_funcs)
if (!pr->load_finish_funcs[--pr->num_load_finish_funcs] (pr))
return 0;
return 1;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
}
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
/*
PR_LoadProgs
*/
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
Simplify the call to PR_LoadProgsFile. I've decided that setting pr.max_edicts and pr.zone_size as part of the local progs initialization rather than in PR_LoadProgsFile makes more sense. For one, it is unlikely for the limits to change every time progs is reloaded. Also, they seem to be a property of the VM rather than the progs. However, there is nothing stopping the caller from updating max_edicts and zone_size every call.
2018-10-11 01:06:48 +00:00
PR_LoadProgs (progs_t *pr, const char *progsname)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
{
go back to using QFile, quakeio.h and quakefs.h
2002-08-27 07:16:28 +00:00
QFile *file;
Separate file search from loading. QFS_LoadFile (and its wrappers) now take a file handle rather than a path. This will make vpath usage a little cleaner to implement.
2014-01-23 02:57:57 +00:00
file = QFS_FOpenFile (progsname);
redo the progs loader to allocate all the memory needed for progs in one shot, allowing for caller specified alloc and edicts and zone memory sizes. (progs + edicts + zone).
2002-01-29 20:53:44 +00:00
pr->progs_name = progsname;
Some bug fixes and memory leak fixes. Local variables break randomly, probably due to my misuse of hash tables. Anyone have any ideas?
2002-03-20 22:57:26 +00:00
if (file) {
Simplify the call to PR_LoadProgsFile. I've decided that setting pr.max_edicts and pr.zone_size as part of the local progs initialization rather than in PR_LoadProgsFile makes more sense. For one, it is unlikely for the limits to change every time progs is reloaded. Also, they seem to be a property of the VM rather than the progs. However, there is nothing stopping the caller from updating max_edicts and zone_size every call.
2018-10-11 01:06:48 +00:00
PR_LoadProgsFile (pr, file, qfs_filesize);
Some bug fixes and memory leak fixes. Local variables break randomly, probably due to my misuse of hash tables. Anyone have any ideas?
2002-03-20 22:57:26 +00:00
Qclose (file);
}
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
if (!pr->progs)
return;
[gamecode] Delay .ctor calls if debugging This allows a debugger to do any symbol lookups and other preparations between loading progs and the first code execution. .ctors are called as per normal if debug_handler is not set.
2020-04-02 08:28:37 +00:00
if (!PR_RunLoadFuncs (pr)) {
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PR_Error (pr, "unable to load %s", progsname);
[gamecode] Delay .ctor calls if debugging This allows a debugger to do any symbol lookups and other preparations between loading progs and the first code execution. .ctors are called as per normal if debug_handler is not set.
2020-04-02 08:28:37 +00:00
}
if (!pr->debug_handler && !PR_RunPostLoadFuncs (pr)) {
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PR_Error (pr, "unable to load %s", progsname);
[gamecode] Delay .ctor calls if debugging This allows a debugger to do any symbol lookups and other preparations between loading progs and the first code execution. .ctors are called as per normal if debug_handler is not set.
2020-04-02 08:28:37 +00:00
}
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PR_Init_Cvars (void)
{
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
Cvar_Register (&pr_boundscheck_cvar, 0, 0);
Cvar_Register (&pr_deadbeef_ents_cvar, 0, 0);
Cvar_Register (&pr_deadbeef_locals_cvar, 0, 0);
Cvar_Register (&pr_faultchecks_cvar, 0, 0);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PR_Debug_Init_Cvars ();
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
Make PR_Init take an instance to initialize This allows internal sub-systems to do per-instance initializations without other engine systems having to know about them.
2020-02-23 06:56:36 +00:00
PR_Init (progs_t *pr)
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
{
Make PR_Init take an instance to initialize This allows internal sub-systems to do per-instance initializations without other engine systems having to know about them.
2020-02-23 06:56:36 +00:00
PR_Resources_Init (pr);
Make progs string resources management private Strangely enough, using the progs resources system. This is a step towards having progs that can be reset properly, or even dynamically created VMs.
2020-02-24 15:21:56 +00:00
PR_Strings_Init (pr);
Make PR_Init take an instance to initialize This allows internal sub-systems to do per-instance initializations without other engine systems having to know about them.
2020-02-23 06:56:36 +00:00
PR_Debug_Init (pr);
[gamecode] Create hash tables in PR_Init This makes much more sense than in PR_LoadProgsFile (and simplifies the latter, too).
2021-12-26 11:33:37 +00:00
pr->function_hash = Hash_NewTable (1021, function_get_key, 0, pr,
pr->hashlink_freelist);
pr->global_hash = Hash_NewTable (1021, var_get_key, 0, pr,
pr->hashlink_freelist);
pr->field_hash = Hash_NewTable (1021, var_get_key, 0, pr,
pr->hashlink_freelist);
[gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so).
2022-02-05 05:07:45 +00:00
pr->type_hash = Hash_NewTable (1021, type_get_key, 0, pr,
pr->hashlink_freelist);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
the big dso visibility patch :). Sure, we have to have unique names for static builds, but with controlled visibitly we should get faster program loads (although this isn't C++, so it's not as bad) and complex plugins are cleaner.
2007-03-10 12:00:59 +00:00
VISIBLE void
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
PR_Error (progs_t *pr, const char *error, ...)
{
va_list argptr;
[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
dstring_t *string = dstring_new ();//FIXME leaks when debugging
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
va_start (argptr, error);
the beginnings of a jihad against buffer overflows
2003-05-08 23:24:02 +00:00
dvsprintf (string, error, argptr);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
va_end (argptr);
[gamecode] Add debug hooks to the VM engine While there was a breakpoint hook, it was for only breakpoints and more was needed. Now there's a generic hook that is called for tracing, breakpoints, watch points, runtime errors and VM errors, with the "event" type passed as the first parameter and a data pointer in the second.
2020-03-24 06:35:42 +00:00
if (pr->debug_handler) {
[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
pr->debug_handler (prd_error, string->str, pr->debug_data);
[gamecode] Add debug hooks to the VM engine While there was a breakpoint hook, it was for only breakpoints and more was needed. Now there's a generic hook that is called for tracing, breakpoints, watch points, runtime errors and VM errors, with the "event" type passed as the first parameter and a data pointer in the second.
2020-03-24 06:35:42 +00:00
// not expected to return, but if so, behave as if there was no handler
}
the beginnings of a jihad against buffer overflows
2003-05-08 23:24:02 +00:00
Sys_Error ("%s: %s", pr->progs_name, string->str);
break out the non-edict code into sensible locations
2002-01-28 17:15:36 +00:00
}
Reference in a new issue Copy permalink