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

1094 lines
28 KiB
C
Raw Normal View History

initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
/*
pr_exec.c
(description)
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
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
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
#include <signal.h>
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
#include <stdarg.h>
move the api headers into include/QF and clean up (most of) the resulting mess. target specific files that I don't build won't compile yet. just put QF/ infront of the offending headers. Also move ver_check into libqfutils
2001-03-27 20:33:07 +00:00
#include "QF/cvar.h"
fix missed header commit
2002-09-14 07:51:53 +00:00
#include "QF/dstring.h"
LordHavoc's VectorIsNull changes from 0.3 but as VectorIsZero (no such thing as a `null' vector) plus a couple of other bits from his patch.
2001-09-11 05:18:15 +00:00
#include "QF/mathlib.h"
move the api headers into include/QF and clean up (most of) the resulting mess. target specific files that I don't build won't compile yet. just put QF/ infront of the offending headers. Also move ver_check into libqfutils
2001-03-27 20:33:07 +00:00
#include "QF/progs.h"
#include "QF/sys.h"
pr_comp.h: add OP_ADD_S. WARNING!!! this /will/ move. progs.h: add prototype for PR_PrintStatement pr_edict.c: add OP_ADD_S support in the progs checker pr_exec.c: implement OP_ADD_S tools/qfcc/include/.gitignore: add config.h.in qfcc.h: nuke PR_NameImmediate and change PR_ParseImmediate's prototype (see pr_imm.c) pr_comp.c: add ADD_S, adjust for PR_ParseImmediate's prototype, make PR_ParseExpression work with non-sequential opcodes (slow, will work on that next). Fix up initialised global parsing. pr_imm.c: nuke PR_NameImmediate. didn't work well and wasn't such a good idea anyway. PR_ParseImmediate now accepts a def_t * arg. if null, will allocate a new global def, otherwise it will initialize the def passed in. qwaq/main.c: sports some debugging code (dumps info about the progs it's running) qwaq/main.qc: better ADD_S testing
2001-06-03 17:36:49 +00:00
#include "QF/zone.h"
#include "compat.h"
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
rhamph's deadbeaf locals patch as-is :)
2001-08-13 20:29:33 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
/*
PR_RunError
Aborts the currently executing function
*/
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
fear the mighty const correct patch
2001-07-15 07:04:17 +00:00
PR_RunError (progs_t * pr, const char *error, ...)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
move the debug related stuff from pr_exec.c to pr_debug.c
2002-10-23 20:42:02 +00:00
dstring_t *string = dstring_new ();
va_list argptr;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
va_start (argptr, error);
move the debug related stuff from pr_exec.c to pr_debug.c
2002-10-23 20:42:02 +00:00
dvsprintf (string, error, argptr);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
va_end (argptr);
break out the backtrace code from PR_RunError into PR_DumpState and use PR_DumpState instead of PR_RunError in seg_fault_handler so we get both a progs trace /and/ a core file (ulimit allowing)
2001-10-08 03:46:44 +00:00
PR_DumpState (pr);
move the debug related stuff from pr_exec.c to pr_debug.c
2002-10-23 20:42:02 +00:00
Sys_Printf ("%s\n", string->str);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break out the backtrace code from PR_RunError into PR_DumpState and use PR_DumpState instead of PR_RunError in seg_fault_handler so we get both a progs trace /and/ a core file (ulimit allowing)
2001-10-08 03:46:44 +00:00
// dump the stack so PR_Error can shutdown functions
Massive whitespace cleanup. Lots of trailing whitespace and otherwise blank lines.
2012-05-21 23:23:22 +00:00
pr->pr_depth = 0;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
move the debug related stuff from pr_exec.c to pr_debug.c
2002-10-23 20:42:02 +00:00
PR_Error (pr, "Program error: %s", string->str);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
correctly save and restore the parameters when calling +initialize. fixes the segfault in the qwaq test.
2007-06-09 13:44:06 +00:00
VISIBLE void
PR_SaveParams (progs_t *pr)
{
int i;
int size = pr->pr_param_size * sizeof (pr_type_t);
pr->pr_param_ptrs[0] = pr->pr_params[0];
pr->pr_param_ptrs[1] = pr->pr_params[1];
pr->pr_params[0] = pr->pr_real_params[0];
pr->pr_params[1] = pr->pr_real_params[1];
for (i = 0; i < pr->pr_argc; i++) {
memcpy (pr->pr_saved_params + i * pr->pr_param_size,
pr->pr_real_params[i], size);
if (i < 2)
memcpy (pr->pr_real_params[i], pr->pr_param_ptrs[0], size);
}
pr->pr_saved_argc = pr->pr_argc;
}
VISIBLE void
PR_RestoreParams (progs_t *pr)
{
int i;
int size = pr->pr_param_size * sizeof (pr_type_t);
pr->pr_params[0] = pr->pr_param_ptrs[0];
pr->pr_params[1] = pr->pr_param_ptrs[1];
pr->pr_argc = pr->pr_saved_argc;
for (i = 0; i < pr->pr_argc; i++)
memcpy (pr->pr_real_params[i],
pr->pr_saved_params + i * pr->pr_param_size, 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 inline void
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
PR_PushFrame (progs_t *pr)
{
prstack_t *frame;
if (pr->pr_depth == MAX_STACK_DEPTH)
PR_RunError (pr, "stack overflow");
frame = pr->pr_stack + pr->pr_depth++;
frame->s = pr->pr_xstatement;
frame->f = pr->pr_xfunction;
frame->tstr = pr->pr_xtstr;
pr->pr_xtstr = 0;
pr->pr_xfunction = 0;
}
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 inline void
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
PR_PopFrame (progs_t *pr)
{
prstack_t *frame;
if (pr->pr_depth <= 0)
PR_Error (pr, "prog stack underflow");
if (pr->pr_xtstr)
PR_FreeTempStrings (pr);
// up stack
frame = pr->pr_stack + --pr->pr_depth;
pr->pr_xfunction = frame->f;
pr->pr_xstatement = frame->s;
pr->pr_xtstr = frame->tstr;
}
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
/** Setup the stackframe prior to calling a progs function. Saves all local
data the called function will trample on and copies the parameters used
by the function into the function's local data space.
\param pr pointer to progs_t VM struct
\param f pointer to the descriptor for the called function
\note Passing a descriptor for a builtin function will result in
undefined behavior.
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
*/
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
static void
Fix the access alignment bug on 64 bit archs.
2007-04-07 01:41:23 +00:00
PR_EnterFunction (progs_t *pr, bfunction_t *f)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
pr_int_t i, j, c, o;
pr_int_t k;
pr_int_t count = 0;
heh, slight oversight when implementing rcall using the param pointer trick. ran into the exact same problem as passing addresses of locals to QC functions. well, actually, that's exactly what it was, but done in the engine. anyway, wound up potentially overwriting the params passed to the function. fortunatly, due to how rcall works, only the first two params are an issue.
2005-06-14 13:40:34 +00:00
int size[2] = {0, 0};
long paramofs = 0;
long offs;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
PR_PushFrame (pr);
heh, slight oversight when implementing rcall using the param pointer trick. ran into the exact same problem as passing addresses of locals to QC functions. well, actually, that's exactly what it was, but done in the engine. anyway, wound up potentially overwriting the params passed to the function. fortunatly, due to how rcall works, only the first two params are an issue.
2005-06-14 13:40:34 +00:00
if (f->numparms > 0) {
for (i = 0; i < 2 && i < f->numparms; i++) {
paramofs += f->parm_size[i];
size[i] = f->parm_size[i];
}
count = i;
} else if (f->numparms < 0) {
for (i = 0; i < 2 && i < -f->numparms - 1; i++) {
paramofs += f->parm_size[i];
size[i] = f->parm_size[i];
}
for (; i < 2; i++) {
paramofs += pr->pr_param_size;
size[i] = pr->pr_param_size;
}
count = i;
}
for (i = 0; i < count && i < pr->pr_argc; i++) {
offs = (pr->pr_params[i] - pr->pr_globals) - f->parm_start;
if (offs >= 0 && offs < paramofs) {
memcpy (pr->pr_real_params[i], pr->pr_params[i],
size[i] * sizeof (pr_type_t));
pr->pr_params[i] = pr->pr_real_params[i];
}
}
elimination of bare printf (with some exceptions) from libs: Sys_Printf is used instead
2001-10-18 16:42:14 +00:00
//Sys_Printf("%s:\n", PR_GetString(pr,f->s_name));
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
pr->pr_xfunction = f;
pr->pr_xstatement = f->first_statement - 1; // offset the st++
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
use memcpy instead of ugly casts to transfer locals
2001-06-05 23:57:51 +00:00
// save off any locals that the new function steps on
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
c = f->locals;
if (pr->localstack_used + c > LOCALSTACK_SIZE)
correct the function names in PR_EnterFunction and PR_LeaveFunction
2002-05-21 21:14:32 +00:00
PR_RunError (pr, "PR_EnterFunction: locals stack overflow");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
use memcpy instead of ugly casts to transfer locals
2001-06-05 23:57:51 +00:00
memcpy (&pr->localstack[pr->localstack_used],
&pr->pr_globals[f->parm_start],
sizeof (pr_type_t) * c);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
pr->localstack_used += c;
- add some comments to libs/console/inputline.c - rename pr_deadbeef to pr_deadbeef_ents - add pr_deadbeef_locals, which does uninited locals. (crashes from it are undeniably buggy code, unlike pr_deadeef_ents) - add a missing break to packetlog printing's switch - add sv_kickfake, which kicks people for attempting to fake messages, or replaces the ^Ms with # if disabled.
2001-09-23 00:36:21 +00:00
if (pr_deadbeef_locals->int_val)
for (k = f->parm_start; k < f->parm_start + c; k++)
pr->pr_globals[k].integer_var = 0xdeadbeef;
rhamph's deadbeaf locals patch as-is :)
2001-08-13 20:29:33 +00:00
Whitespace.
2001-09-10 12:56:23 +00:00
// copy parameters
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
o = f->parm_start;
vararg functions can now be imlemented in qc using @argc (number of params passed through ...) and @argv (array of vectors, one for each ... param)
2002-05-22 20:43:29 +00:00
if (f->numparms >= 0) {
for (i = 0; i < f->numparms; i++) {
for (j = 0; j < f->parm_size[i]; j++) {
remove all references to OFS_* from the C code. only the macros in progs.h use them now
2003-04-22 18:20:15 +00:00
memcpy (&pr->pr_globals[o], &P_INT (pr, i) + j,
vararg functions can now be imlemented in qc using @argc (number of params passed through ...) and @argv (array of vectors, one for each ... param)
2002-05-22 20:43:29 +00:00
sizeof (pr_type_t));
o++;
}
}
} else {
pr_type_t *argc = &pr->pr_globals[o++];
pr_type_t *argv = &pr->pr_globals[o++];
for (i = 0; i < -f->numparms - 1; i++) {
for (j = 0; j < f->parm_size[i]; j++) {
remove all references to OFS_* from the C code. only the macros in progs.h use them now
2003-04-22 18:20:15 +00:00
memcpy (&pr->pr_globals[o], &P_INT (pr, i) + j,
vararg functions can now be imlemented in qc using @argc (number of params passed through ...) and @argv (array of vectors, one for each ... param)
2002-05-22 20:43:29 +00:00
sizeof (pr_type_t));
o++;
}
}
argc->integer_var = pr->pr_argc - i;
argv->integer_var = o;
can now handle > vector sized parameters
2003-04-22 20:11:16 +00:00
if (i < MAX_PARMS) {
memcpy (&pr->pr_globals[o], &P_INT (pr, i),
(MAX_PARMS - i) * pr->pr_param_size * sizeof (pr_type_t));
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
}
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static void
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
PR_LeaveFunction (progs_t *pr)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
Whitespace.
2001-09-10 12:56:23 +00:00
int c;
Fix the access alignment bug on 64 bit archs.
2007-04-07 01:41:23 +00:00
bfunction_t *f = pr->pr_xfunction;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
PR_PopFrame (pr);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Whitespace.
2001-09-10 12:56:23 +00:00
// restore locals from the stack
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
c = f->locals;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
pr->localstack_used -= c;
if (pr->localstack_used < 0)
correct the function names in PR_EnterFunction and PR_LeaveFunction
2002-05-21 21:14:32 +00:00
PR_RunError (pr, "PR_LeaveFunction: locals stack underflow");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
add PR_PushFrame and PR_PopFrame so temp strings are easy to use for parameters to progs functions. double the progs stack sizes (call depth of 32? eek) allow one extra call on the progs stack :) misc minor cleanups
2004-01-05 07:10:32 +00:00
memcpy (&pr->pr_globals[f->parm_start],
&pr->localstack[pr->localstack_used], sizeof (pr_type_t) * c);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
Really nail down the args param in rua_obj_msg_sendv().
2010-01-13 06:36:16 +00:00
VISIBLE void
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
PR_BoundsCheckSize (progs_t *pr, int addr, unsigned size)
{
if (addr < 0 || addr >= pr->globals_size
|| size > (unsigned) (pr->globals_size - addr))
PR_RunError (pr, "invalid memory access: %d (0 to %d-%d)", addr,
pr->globals_size, size);
Add improved memory checking to progs. With pr_boundscheck >= 2, pointer access will be checked against allocated blocks (qfvalgrind?:). Currently extremely basic, but it seems to work.
2012-11-19 11:03:21 +00:00
if (pr_boundscheck->int_val >= 2
&& PR_GetPointer (pr, addr + size) > (pr_type_t *) pr->zone) {
void *mem = (void *) PR_GetPointer (pr, addr);
Z_CheckPointer (pr->zone, mem, size * sizeof (pr_type_t));
}
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
}
Really nail down the args param in rua_obj_msg_sendv().
2010-01-13 06:36:16 +00:00
VISIBLE void
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
PR_BoundsCheck (progs_t *pr, int addr, etype_t type)
{
PR_BoundsCheckSize (pr, addr, pr_type_size[type]);
}
this should speed up progs a little bit
2002-06-07 19:41:13 +00:00
#define OPA (*op_a)
#define OPB (*op_b)
#define OPC (*op_c)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
make float != 0 tests work on alpha for when the value is actually an integer (works fine on intel, but on alpha the denormals either produce an exception or true zero: not quite desirable:)
2001-11-19 17:51:31 +00:00
/*
This gets around the problem of needing to test for -0.0 but denormals
causing exceptions (or wrong results for what we need) on the alpha.
*/
make qf gcc 3.3 clean
2003-04-17 00:01:48 +00:00
#define FNZ(x) ((x).uinteger_var && (x).uinteger_var != 0x80000000u)
make float != 0 tests work on alpha for when the value is actually an integer (works fine on intel, but on alpha the denormals either produce an exception or true zero: not quite desirable:)
2001-11-19 17:51:31 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
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
static int
signal_hook (int sig, void *data)
{
progs_t *pr = (progs_t *) data;
Massive whitespace cleanup. Lots of trailing whitespace and otherwise blank lines.
2012-05-21 23:23:22 +00:00
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
if (sig == SIGFPE && pr_faultchecks->int_val) {
dstatement_t *st;
pr_type_t *op_a, *op_b, *op_c;
st = pr->pr_statements + pr->pr_xstatement;
op_a = pr->pr_globals + st->a;
op_b = pr->pr_globals + st->b;
op_c = pr->pr_globals + st->c;
switch (st->op) {
case OP_DIV_F:
if ((OPA.integer_var & 0x80000000)
^ (OPB.integer_var & 0x80000000))
OPC.integer_var = 0xff7fffff;
else
OPC.integer_var = 0x7f7fffff;
return 1;
case OP_DIV_I:
if (OPA.integer_var & 0x80000000)
OPC.integer_var = -0x80000000;
else
OPC.integer_var = 0x7fffffff;
return 1;
handle x % 0 by giving a 0 result
2004-02-20 00:25:08 +00:00
case OP_MOD_I:
case OP_MOD_F:
OPC.integer_var = 0x00000000;
return 1;
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
default:
break;
}
}
PR_DumpState (pr);
Ensure stdout is flushed in the progs signal_hook()
2011-03-20 04:34:28 +00:00
fflush (stdout);
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
return 0;
}
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
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
PR_CallFunction (progs_t *pr, func_t fnum)
{
Fix the access alignment bug on 64 bit archs.
2007-04-07 01:41:23 +00:00
bfunction_t *f;
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
if (!fnum)
PR_RunError (pr, "NULL function");
Fix the access alignment bug on 64 bit archs.
2007-04-07 01:41:23 +00:00
f = pr->function_table + fnum;
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
if (f->first_statement < 0) {
// negative statements are built in functions
Fix the access alignment bug on 64 bit archs.
2007-04-07 01:41:23 +00:00
f->func (pr);
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
return 0;
} else {
PR_EnterFunction (pr, f);
return 1;
}
}
Whitespace.
2001-09-10 12:56:23 +00:00
/*
PR_ExecuteProgram
The interpretation main loop
*/
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
new operand handling from nq
2001-02-27 08:21:40 +00:00
PR_ExecuteProgram (progs_t * pr, func_t fnum)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
int exitdepth, profile, startprofile;
pr_uint_t pointer;
dstatement_t *st;
edict_t *ed;
pr_type_t *ptr;
fix a couple of gcc 4.5 issues that Despair pointed out (I don't have it yet)
2010-05-27 12:21:50 +00:00
pr_type_t old_val = {0}, *watch = 0;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Whitespace.
2001-09-10 12:56:23 +00:00
// make a stack frame
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
exitdepth = pr->pr_depth;
startprofile = profile = 0;
Move the signal handling code from video/targets/* to sys.c (I'm leaving the SDL target files for Despair since he's working on the currently). Also make progs segfault handling much more robust (and general: sigill etc too:)
2002-08-20 23:04:57 +00:00
Sys_PushSignalHook (signal_hook, pr);
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
if (!PR_CallFunction (pr, fnum)) {
// called a builtin instead of progs code
Sys_PopSignalHook ();
return;
}
st = pr->pr_statements + pr->pr_xstatement;
"hardware" (haha) watch points (one!) in progs. only catches changes done by progs, and the expression parser is as flaky as anything, but it's better than nothing :)
2007-05-08 02:04:47 +00:00
if (pr->watch) {
watch = pr->watch;
old_val = *watch;
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
while (1) {
this should speed up progs a little bit
2002-06-07 19:41:13 +00:00
pr_type_t *op_a, *op_b, *op_c;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
st++;
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
++pr->pr_xstatement;
if (pr->pr_xstatement != st - pr->pr_statements)
PR_RunError (pr, "internal error");
fix up #0 builtin functions at runtime. not done automaticly (need to call PR_RelocateBuiltins) and fix a bug with profiling and unlimited execution counts
2001-12-14 08:15:04 +00:00
if (++profile > 1000000 && !pr->no_exec_limit) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
PR_RunError (pr, "runaway loop error");
}
this should speed up progs a little bit
2002-06-07 19:41:13 +00:00
op_a = pr->pr_globals + st->a;
op_b = pr->pr_globals + st->b;
op_c = pr->pr_globals + st->c;
more debug changes. not there yet
2001-03-02 00:32:10 +00:00
if (pr->pr_trace)
make printing of global contents in PR_PrintStatement optional so disassembly output is cleaner
2004-01-31 04:26:01 +00:00
PR_PrintStatement (pr, st, 1);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
switch (st->op) {
case OP_ADD_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var + OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_ADD_V:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorAdd (OPA.vector_var, OPB.vector_var, OPC.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_ADD_Q:
QuatAdd (OPA.quat_var, OPB.quat_var, OPC.quat_var);
break;
pr_comp.h: add OP_ADD_S. WARNING!!! this /will/ move. progs.h: add prototype for PR_PrintStatement pr_edict.c: add OP_ADD_S support in the progs checker pr_exec.c: implement OP_ADD_S tools/qfcc/include/.gitignore: add config.h.in qfcc.h: nuke PR_NameImmediate and change PR_ParseImmediate's prototype (see pr_imm.c) pr_comp.c: add ADD_S, adjust for PR_ParseImmediate's prototype, make PR_ParseExpression work with non-sequential opcodes (slow, will work on that next). Fix up initialised global parsing. pr_imm.c: nuke PR_NameImmediate. didn't work well and wasn't such a good idea anyway. PR_ParseImmediate now accepts a def_t * arg. if null, will allocate a new global def, otherwise it will initialize the def passed in. qwaq/main.c: sports some debugging code (dumps info about the progs it's running) qwaq/main.qc: better ADD_S testing
2001-06-03 17:36:49 +00:00
case OP_ADD_S:
avoid using the hunk in the progs engine (except for the override-able load and alloc functions) so tools (qfprogs and qwaq) don't need to create it. register only the first instance of a progs provided string This is an imperfect revision of history.
2004-11-02 04:59:00 +00:00
OPC.string_var = PR_CatStrings (pr,
PR_GetString (pr,
OPA.string_var),
PR_GetString (pr,
OPB.string_var));
pr_comp.h: add OP_ADD_S. WARNING!!! this /will/ move. progs.h: add prototype for PR_PrintStatement pr_edict.c: add OP_ADD_S support in the progs checker pr_exec.c: implement OP_ADD_S tools/qfcc/include/.gitignore: add config.h.in qfcc.h: nuke PR_NameImmediate and change PR_ParseImmediate's prototype (see pr_imm.c) pr_comp.c: add ADD_S, adjust for PR_ParseImmediate's prototype, make PR_ParseExpression work with non-sequential opcodes (slow, will work on that next). Fix up initialised global parsing. pr_imm.c: nuke PR_NameImmediate. didn't work well and wasn't such a good idea anyway. PR_ParseImmediate now accepts a def_t * arg. if null, will allocate a new global def, otherwise it will initialize the def passed in. qwaq/main.c: sports some debugging code (dumps info about the progs it's running) qwaq/main.qc: better ADD_S testing
2001-06-03 17:36:49 +00:00
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_SUB_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var - OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_SUB_V:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorSubtract (OPA.vector_var, OPB.vector_var, OPC.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_SUB_Q:
QuatSubtract (OPA.quat_var, OPB.quat_var, OPC.quat_var);
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_MUL_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var * OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_MUL_V:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
OPC.float_var = DotProduct (OPA.vector_var, OPB.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_MUL_FV:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorScale (OPB.vector_var, OPA.float_var, OPC.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_MUL_VF:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorScale (OPA.vector_var, OPB.float_var, OPC.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_MUL_Q:
QuatMult (OPA.quat_var, OPB.quat_var, OPC.quat_var);
break;
Add vec = quat * vec to the progs engine.
2012-04-26 01:29:21 +00:00
case OP_MUL_QV:
QuatMultVec (OPA.quat_var, OPB.vector_var, OPC.vector_var);
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_MUL_FQ:
QuatScale (OPB.quat_var, OPA.float_var, OPC.quat_var);
break;
case OP_MUL_QF:
QuatScale (OPA.quat_var, OPB.float_var, OPC.quat_var);
break;
quaternion conjugate support (engine side)
2004-04-08 04:57:17 +00:00
case OP_CONJ_Q:
QuatConj (OPA.quat_var, OPC.quat_var);
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_DIV_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var / OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_BITAND:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = (int) OPA.float_var & (int) OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_BITOR:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = (int) OPA.float_var | (int) OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
^ and ~ operators for qc (^ from Rhamphoryncus) and clean up the punctuation line in qc-lex.l (why didn't I think to do that in the first place?!?)
2001-08-09 16:34:46 +00:00
case OP_BITXOR_F:
OPC.float_var = (int) OPA.float_var ^ (int) OPB.float_var;
break;
case OP_BITNOT_F:
OPC.float_var = ~ (int) OPA.float_var;
break;
got a few new operators for qc :) << >> % which all act like their C counterparts += -= *= /= &= ^= |= <<= >>= %= which just expand into the obvious, also like the C versions.
2001-08-10 16:17:00 +00:00
case OP_SHL_F:
OPC.float_var = (int) OPA.float_var << (int) OPB.float_var;
break;
case OP_SHR_F:
OPC.float_var = (int) OPA.float_var >> (int) OPB.float_var;
break;
case OP_SHL_I:
OPC.integer_var = OPA.integer_var << OPB.integer_var;
break;
case OP_SHR_I:
OPC.integer_var = OPA.integer_var >> OPB.integer_var;
break;
get unsigned mostly working
2003-08-01 21:20:04 +00:00
case OP_SHR_U:
Bring back the unsigned type (PROGS version bump) This is only low-level support (the unsigned keyword still does not work), but sufficient to make switch statements using jump tables work.
2011-04-09 01:07:47 +00:00
OPC.uinteger_var = OPA.uinteger_var >> OPB.integer_var;
get unsigned mostly working
2003-08-01 21:20:04 +00:00
break;
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_GE_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var >= OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_LE_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var <= OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_GT_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var > OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_LT_F:
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
OPC.float_var = OPA.float_var < OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
change the results of the test instructions from float to int.
2001-07-22 19:58:17 +00:00
case OP_AND: // OPA and OPB have to be float for -0.0
make float != 0 tests work on alpha for when the value is actually an integer (works fine on intel, but on alpha the denormals either produce an exception or true zero: not quite desirable:)
2001-11-19 17:51:31 +00:00
OPC.integer_var = FNZ (OPA) && FNZ (OPB);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
fix up #0 builtin functions at runtime. not done automaticly (need to call PR_RelocateBuiltins) and fix a bug with profiling and unlimited execution counts
2001-12-14 08:15:04 +00:00
case OP_OR: // OPA and OPB have to be float for -0.0
make float != 0 tests work on alpha for when the value is actually an integer (works fine on intel, but on alpha the denormals either produce an exception or true zero: not quite desirable:)
2001-11-19 17:51:31 +00:00
OPC.integer_var = FNZ (OPA) || FNZ (OPB);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NOT_F:
make float != 0 tests work on alpha for when the value is actually an integer (works fine on intel, but on alpha the denormals either produce an exception or true zero: not quite desirable:)
2001-11-19 17:51:31 +00:00
OPC.integer_var = !FNZ (OPA);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NOT_V:
LordHavoc's VectorIsNull changes from 0.3 but as VectorIsZero (no such thing as a `null' vector) plus a couple of other bits from his patch.
2001-09-11 05:18:15 +00:00
OPC.integer_var = VectorIsZero (OPA.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_NOT_Q:
OPC.integer_var = QuatIsZero (OPA.quat_var);
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_NOT_S:
Whitespace.
2001-09-10 12:56:23 +00:00
OPC.integer_var = !OPA.string_var ||
!*PR_GetString (pr, OPA.string_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_NOT_FN:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = !OPA.func_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NOT_ENT:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = !OPA.entity_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_EQ_F:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.float_var == OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_EQ_V:
more mathlib usage
2001-11-06 20:36:20 +00:00
OPC.integer_var = VectorCompare (OPA.vector_var,
OPB.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_EQ_Q:
OPC.integer_var = QuatCompare (OPA.quat_var, OPB.quat_var);
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_EQ_E:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var == OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_EQ_FN:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.func_var == OPB.func_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NE_F:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.float_var != OPB.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NE_V:
more mathlib usage
2001-11-06 20:36:20 +00:00
OPC.integer_var = !VectorCompare (OPA.vector_var,
OPB.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_NE_Q:
OPC.integer_var = !QuatCompare (OPA.quat_var, OPB.quat_var);
break;
string comparison operators
2001-06-04 03:36:35 +00:00
case OP_LE_S:
case OP_GE_S:
case OP_LT_S:
case OP_GT_S:
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_NE_S:
string comparison operators
2001-06-04 03:36:35 +00:00
case OP_EQ_S:
{
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
int cmp = strcmp (PR_GetString (pr, OPA.string_var),
PR_GetString (pr, OPB.string_var));
string comparison operators
2001-06-04 03:36:35 +00:00
switch (st->op) {
case OP_LE_S: cmp = (cmp <= 0); break;
case OP_GE_S: cmp = (cmp >= 0); break;
case OP_LT_S: cmp = (cmp < 0); break;
case OP_GT_S: cmp = (cmp > 0); break;
case OP_NE_S: break;
case OP_EQ_S: cmp = !cmp; break;
blah, enums and switch... (at least gcc 3.1 is warning about that again:)
2002-06-09 16:31:08 +00:00
default: break;
string comparison operators
2001-06-04 03:36:35 +00:00
}
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = cmp;
string comparison operators
2001-06-04 03:36:35 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NE_E:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var != OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_NE_FN:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.func_var != OPB.func_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
new operand handling from nq
2001-02-27 08:21:40 +00:00
// ==================
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_STORE_F:
case OP_STORE_ENT:
case OP_STORE_FLD: // integers
case OP_STORE_S:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_STORE_FN: // pointers
redundant code removal
2001-11-02 03:04:01 +00:00
case OP_STORE_I:
forgot to implement store.p
2002-01-23 22:33:22 +00:00
case OP_STORE_P:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPB.integer_var = OPA.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_STORE_V:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorCopy (OPA.vector_var, OPB.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_STORE_Q:
QuatCopy (OPA.quat_var, OPB.quat_var);
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_STOREP_F:
case OP_STOREP_ENT:
case OP_STOREP_FLD: // integers
case OP_STOREP_S:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_STOREP_FN: // pointers
redundant code removal
2001-11-02 03:04:01 +00:00
case OP_STOREP_I:
pr_*: add storep.p so pointers can be stored into entities emit.c: convert & (address) to . in unary . rewrite emit_assign_expr expr.c: remove debug code and make unary . less agressive on address calcs also convert & (address) to . for lvals
2001-12-12 20:35:58 +00:00
case OP_STOREP_P:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
pointer = OPB.integer_var;
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
ptr = pr->pr_globals + pointer;
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
ptr->integer_var = OPA.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_STOREP_V:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
pointer = OPB.integer_var;
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_vector);
}
ptr = pr->pr_globals + pointer;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorCopy (OPA.vector_var, ptr->vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_STOREP_Q:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
pointer = OPB.integer_var;
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_quat);
}
ptr = pr->pr_globals + pointer;
engine side quaternion support
2004-04-08 00:56:30 +00:00
QuatCopy (OPA.quat_var, ptr->quat_var);
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_ADDRESS:
do a pre and post pass for maps/mapname.cfg and use maps_default.cfg if maps/mapname.cfg doesn't exist.
2002-11-08 02:43:04 +00:00
if (pr_boundscheck->int_val) {
if (OPA.entity_var < 0
|| OPA.entity_var >= pr->pr_edictareasize)
PR_RunError (pr, "Progs attempted to address an out "
"of bounds edict");
if (OPA.entity_var == 0 && pr->null_bad)
PR_RunError (pr, "assignment to world entity");
make qf gcc 3.3 clean
2003-04-17 00:01:48 +00:00
if (OPB.uinteger_var >= pr->progs->entityfields)
do a pre and post pass for maps/mapname.cfg and use maps_default.cfg if maps/mapname.cfg doesn't exist.
2002-11-08 02:43:04 +00:00
PR_RunError (pr, "Progs attempted to address an "
"invalid field in an edict");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
ed = PROG_TO_EDICT (pr, OPA.entity_var);
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
OPC.integer_var = &ed->v[OPB.integer_var] - pr->pr_globals;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
Add a void address instruction.
2011-03-10 10:28:03 +00:00
case OP_ADDRESS_VOID:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_ADDRESS_F:
case OP_ADDRESS_V:
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_ADDRESS_Q:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_ADDRESS_S:
case OP_ADDRESS_ENT:
case OP_ADDRESS_FLD:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_ADDRESS_FN:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_ADDRESS_I:
case OP_ADDRESS_P:
OPC.integer_var = st->a;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_LOAD_F:
case OP_LOAD_FLD:
case OP_LOAD_ENT:
case OP_LOAD_S:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_LOAD_FN:
redundant code removal
2001-11-02 03:04:01 +00:00
case OP_LOAD_I:
change the operator for "address" from "." to "&" so load.p can be implement. this makes it so pointers in entities work.
2001-12-08 20:17:20 +00:00
case OP_LOAD_P:
do a pre and post pass for maps/mapname.cfg and use maps_default.cfg if maps/mapname.cfg doesn't exist.
2002-11-08 02:43:04 +00:00
if (pr_boundscheck->int_val) {
if (OPA.entity_var < 0
|| OPA.entity_var >= pr->pr_edictareasize)
PR_RunError (pr, "Progs attempted to read an out of "
"bounds edict number");
make qf gcc 3.3 clean
2003-04-17 00:01:48 +00:00
if (OPB.uinteger_var >= pr->progs->entityfields)
do a pre and post pass for maps/mapname.cfg and use maps_default.cfg if maps/mapname.cfg doesn't exist.
2002-11-08 02:43:04 +00:00
PR_RunError (pr, "Progs attempted to read an invalid "
"field in an edict");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
ed = PROG_TO_EDICT (pr, OPA.entity_var);
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = ed->v[OPB.integer_var].integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_LOAD_V:
do a pre and post pass for maps/mapname.cfg and use maps_default.cfg if maps/mapname.cfg doesn't exist.
2002-11-08 02:43:04 +00:00
if (pr_boundscheck->int_val) {
if (OPA.entity_var < 0
|| OPA.entity_var >= pr->pr_edictareasize)
engine side quaternion support
2004-04-08 00:56:30 +00:00
PR_RunError (pr, "Progs attempted to read an out of "
"bounds edict number");
make qf gcc 3.3 clean
2003-04-17 00:01:48 +00:00
if (OPB.uinteger_var + 2 >= pr->progs->entityfields)
engine side quaternion support
2004-04-08 00:56:30 +00:00
PR_RunError (pr, "Progs attempted to read an invalid "
"field in an edict");
}
ed = PROG_TO_EDICT (pr, OPA.entity_var);
memcpy (&OPC, &ed->v[OPB.integer_var], 3 * sizeof (OPC));
break;
case OP_LOAD_Q:
if (pr_boundscheck->int_val) {
if (OPA.entity_var < 0
|| OPA.entity_var >= pr->pr_edictareasize)
PR_RunError (pr, "Progs attempted to read an out of "
"bounds edict number");
if (OPB.uinteger_var + 3 >= pr->progs->entityfields)
PR_RunError (pr, "Progs attempted to read an invalid "
"field in an edict");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
ed = PROG_TO_EDICT (pr, OPA.entity_var);
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
memcpy (&OPC, &ed->v[OPB.integer_var], 3 * sizeof (OPC));
new operand handling from nq
2001-02-27 08:21:40 +00:00
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_LOADB_F:
case OP_LOADB_S:
case OP_LOADB_ENT:
case OP_LOADB_FLD:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_LOADB_FN:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_LOADB_I:
case OP_LOADB_P:
pointer = OPA.integer_var + OPB.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
ptr = pr->pr_globals + pointer;
OPC.integer_var = ptr->integer_var;
break;
case OP_LOADB_V:
pointer = OPA.integer_var + OPB.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_vector);
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
ptr = pr->pr_globals + pointer;
VectorCopy (ptr->vector_var, OPC.vector_var);
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_LOADB_Q:
pointer = OPA.integer_var + OPB.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_quat);
}
engine side quaternion support
2004-04-08 00:56:30 +00:00
ptr = pr->pr_globals + pointer;
QuatCopy (ptr->quat_var, OPC.quat_var);
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
case OP_LOADBI_F:
case OP_LOADBI_S:
case OP_LOADBI_ENT:
case OP_LOADBI_FLD:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_LOADBI_FN:
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
case OP_LOADBI_I:
case OP_LOADBI_P:
pointer = OPA.integer_var + (short) st->b;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
ptr = pr->pr_globals + pointer;
OPC.integer_var = ptr->integer_var;
break;
case OP_LOADBI_V:
pointer = OPA.integer_var + (short) st->b;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_vector);
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
ptr = pr->pr_globals + pointer;
VectorCopy (ptr->vector_var, OPC.vector_var);
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_LOADBI_Q:
pointer = OPA.integer_var + (short) st->b;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_quat);
}
engine side quaternion support
2004-04-08 00:56:30 +00:00
ptr = pr->pr_globals + pointer;
QuatCopy (ptr->quat_var, OPC.quat_var);
break;
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_LEA:
pointer = OPA.integer_var + OPB.integer_var;
OPC.integer_var = pointer;
break;
ok, structures seem to generate correct code now
2001-12-08 08:19:48 +00:00
case OP_LEAI:
pointer = OPA.integer_var + (short) st->b;
OPC.integer_var = pointer;
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_STOREB_F:
case OP_STOREB_S:
case OP_STOREB_ENT:
case OP_STOREB_FLD:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_STOREB_FN:
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
case OP_STOREB_I:
case OP_STOREB_P:
pointer = OPB.integer_var + OPC.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
ptr = pr->pr_globals + pointer;
ptr->integer_var = OPA.integer_var;
break;
case OP_STOREB_V:
pointer = OPB.integer_var + OPC.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_vector);
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
ptr = pr->pr_globals + pointer;
VectorCopy (OPA.vector_var, ptr->vector_var);
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_STOREB_Q:
pointer = OPB.integer_var + OPC.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_quat);
}
engine side quaternion support
2004-04-08 00:56:30 +00:00
ptr = pr->pr_globals + pointer;
QuatCopy (OPA.quat_var, ptr->quat_var);
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
case OP_STOREBI_F:
case OP_STOREBI_S:
case OP_STOREBI_ENT:
case OP_STOREBI_FLD:
change FNC to FN and fnc to fn for function based opcodes
2004-02-11 06:52:19 +00:00
case OP_STOREBI_FN:
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
case OP_STOREBI_I:
case OP_STOREBI_P:
pointer = OPB.integer_var + (short) st->c;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
ptr = pr->pr_globals + pointer;
ptr->integer_var = OPA.integer_var;
break;
case OP_STOREBI_V:
pointer = OPB.integer_var + (short) st->c;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_vector);
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
ptr = pr->pr_globals + pointer;
VectorCopy (OPA.vector_var, ptr->vector_var);
break;
engine side quaternion support
2004-04-08 00:56:30 +00:00
case OP_STOREBI_Q:
pointer = OPB.integer_var + (short) st->c;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_quat);
}
engine side quaternion support
2004-04-08 00:56:30 +00:00
ptr = pr->pr_globals + pointer;
QuatCopy (OPA.quat_var, ptr->quat_var);
break;
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
new operand handling from nq
2001-02-27 08:21:40 +00:00
// ==================
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_IFNOT:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (!OPA.integer_var) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_IF:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (OPA.integer_var) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
case OP_IFBE:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (OPA.integer_var <= 0) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
case OP_IFB:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (OPA.integer_var < 0) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
case OP_IFAE:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (OPA.integer_var >= 0) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
case OP_IFA:
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
if (OPA.integer_var > 0) {
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->b - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
}
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_GOTO:
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement += (short)st->a - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
case OP_JUMP:
if (pr_boundscheck->int_val
&& (OPA.uinteger_var >= pr->progs->numstatements)) {
search for `.self' before `self'
2002-05-18 00:49:16 +00:00
PR_RunError (pr, "Invalid jump destination");
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
}
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
pr->pr_xstatement = OPA.uinteger_var;
st = pr->pr_statements + pr->pr_xstatement;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
pr_comp.h: o add OP_JUMPB o OP_JUMPB renumberd some opcodes, so up PROG_VERSION pr_edict.c: o make the version error reporting more informative pr_exec.c: o implement OP_JUMPB (goto *(ptr + index)) pr_opcode.c: (libs/gamecode/engine) o add OP_JUMPB to the table expr.h: o ex_uinteger support o some const correctness o prototype new_label_expr qfcc.h: o uinteger ussport o add pointers for op_jump and op_jumpb o prototype PR_GetArray emit.c: o general uinteger support o new reference/reloc type 3: absolute statement address o jumpb support (binary goto) expr.c: o uinteger support o break the label name creation out of new_label_expr into new_label_name o some const correctness pr_def.c: o add PR_GetArray to allocate an array in global space o factor out some code common to PR_GetDef and PR_GetArray that would otherwise be duplicated pr_imm.c: o some const correctness o uinteger support pr_lex.c: o uinteger support pr_opcode.c: (tools/qfcc/source) o support jump and jumpb switch.c: o rewrite the binary search code to support ranges.
2001-11-13 08:58:54 +00:00
case OP_JUMPB:
implement jumpb correctly
2003-08-22 19:48:36 +00:00
pointer = st->a + OPB.integer_var;
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
}
pr_comp.h: o add OP_JUMPB o OP_JUMPB renumberd some opcodes, so up PROG_VERSION pr_edict.c: o make the version error reporting more informative pr_exec.c: o implement OP_JUMPB (goto *(ptr + index)) pr_opcode.c: (libs/gamecode/engine) o add OP_JUMPB to the table expr.h: o ex_uinteger support o some const correctness o prototype new_label_expr qfcc.h: o uinteger ussport o add pointers for op_jump and op_jumpb o prototype PR_GetArray emit.c: o general uinteger support o new reference/reloc type 3: absolute statement address o jumpb support (binary goto) expr.c: o uinteger support o break the label name creation out of new_label_expr into new_label_name o some const correctness pr_def.c: o add PR_GetArray to allocate an array in global space o factor out some code common to PR_GetDef and PR_GetArray that would otherwise be duplicated pr_imm.c: o some const correctness o uinteger support pr_lex.c: o uinteger support pr_opcode.c: (tools/qfcc/source) o support jump and jumpb switch.c: o rewrite the binary search code to support ranges.
2001-11-13 08:58:54 +00:00
ptr = pr->pr_globals + pointer;
pointer = ptr->integer_var;
if (pr_boundscheck->int_val
&& (pointer >= pr->progs->numstatements)) {
search for `.self' before `self'
2002-05-18 00:49:16 +00:00
PR_RunError (pr, "Invalid jump destination");
pr_comp.h: o add OP_JUMPB o OP_JUMPB renumberd some opcodes, so up PROG_VERSION pr_edict.c: o make the version error reporting more informative pr_exec.c: o implement OP_JUMPB (goto *(ptr + index)) pr_opcode.c: (libs/gamecode/engine) o add OP_JUMPB to the table expr.h: o ex_uinteger support o some const correctness o prototype new_label_expr qfcc.h: o uinteger ussport o add pointers for op_jump and op_jumpb o prototype PR_GetArray emit.c: o general uinteger support o new reference/reloc type 3: absolute statement address o jumpb support (binary goto) expr.c: o uinteger support o break the label name creation out of new_label_expr into new_label_name o some const correctness pr_def.c: o add PR_GetArray to allocate an array in global space o factor out some code common to PR_GetDef and PR_GetArray that would otherwise be duplicated pr_imm.c: o some const correctness o uinteger support pr_lex.c: o uinteger support pr_opcode.c: (tools/qfcc/source) o support jump and jumpb switch.c: o rewrite the binary search code to support ranges.
2001-11-13 08:58:54 +00:00
}
bah, forgot to -1 the instruction pointer for jumpb
2003-08-24 07:23:12 +00:00
pr->pr_xstatement = pointer - 1; // offset the st++
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
pr_comp.h: o add OP_JUMPB o OP_JUMPB renumberd some opcodes, so up PROG_VERSION pr_edict.c: o make the version error reporting more informative pr_exec.c: o implement OP_JUMPB (goto *(ptr + index)) pr_opcode.c: (libs/gamecode/engine) o add OP_JUMPB to the table expr.h: o ex_uinteger support o some const correctness o prototype new_label_expr qfcc.h: o uinteger ussport o add pointers for op_jump and op_jumpb o prototype PR_GetArray emit.c: o general uinteger support o new reference/reloc type 3: absolute statement address o jumpb support (binary goto) expr.c: o uinteger support o break the label name creation out of new_label_expr into new_label_name o some const correctness pr_def.c: o add PR_GetArray to allocate an array in global space o factor out some code common to PR_GetDef and PR_GetArray that would otherwise be duplicated pr_imm.c: o some const correctness o uinteger support pr_lex.c: o uinteger support pr_opcode.c: (tools/qfcc/source) o support jump and jumpb switch.c: o rewrite the binary search code to support ranges.
2001-11-13 08:58:54 +00:00
break;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
case OP_RCALL2:
case OP_RCALL3:
case OP_RCALL4:
case OP_RCALL5:
case OP_RCALL6:
case OP_RCALL7:
case OP_RCALL8:
pr->pr_params[1] = &OPC;
goto op_rcall;
case OP_RCALL1:
pr->pr_params[1] = pr->pr_real_params[1];
op_rcall:
pr->pr_params[0] = &OPB;
pr->pr_argc = st->op - OP_RCALL1 + 1;
goto op_call;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_CALL0:
case OP_CALL1:
case OP_CALL2:
case OP_CALL3:
case OP_CALL4:
case OP_CALL5:
case OP_CALL6:
case OP_CALL7:
case OP_CALL8:
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
PR_RESET_PARAMS (pr);
pr->pr_argc = st->op - OP_CALL0;
op_call:
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
pr->pr_xfunction->profile += profile - startprofile;
startprofile = profile;
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
PR_CallFunction (pr, OPA.func_var);
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
st = pr->pr_statements + pr->pr_xstatement;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_DONE:
case OP_RETURN:
handle "return 0" a bit better. assumes location is is always 0, but it always has been (and always /should/ be anyway:)
2003-08-13 17:27:34 +00:00
if (!st->a)
memset (&R_INT (pr), 0,
pr->pr_param_size * sizeof (OPA));
else if (&R_INT (pr) != &OPA.integer_var)
don't bother doing the copy if the value to be returned is already in the return slot
2003-08-13 17:07:05 +00:00
memcpy (&R_INT (pr), &OPA,
pr->pr_param_size * sizeof (OPA));
Add a "void return" instruction. I got fed up with always having to explicty return something.
2011-01-12 15:29:56 +00:00
// fallthrough
case OP_RETURN_V:
fix an accounting error
2003-09-15 21:13:13 +00:00
pr->pr_xfunction->profile += profile - startprofile;
startprofile = profile;
pr_xstatement now always reflects the currently executing statement making debugging easier in the event of a segfault
2002-10-22 15:07:54 +00:00
PR_LeaveFunction (pr);
st = pr->pr_statements + pr->pr_xstatement;
Move the signal handling code from video/targets/* to sys.c (I'm leaving the SDL target files for Despair since he's working on the currently). Also make progs segfault handling much more robust (and general: sigill etc too:)
2002-08-20 23:04:57 +00:00
if (pr->pr_depth == exitdepth) {
make a common call function and fix pr_trace such that it autoclears only when the execution session it's set in is exited This is an imperfect revision of history.
2004-11-07 03:00:00 +00:00
if (pr->pr_trace && pr->pr_depth <= pr->pr_trace_depth)
pr->pr_trace = false;
Move the signal handling code from video/targets/* to sys.c (I'm leaving the SDL target files for Despair since he's working on the currently). Also make progs segfault handling much more robust (and general: sigill etc too:)
2002-08-20 23:04:57 +00:00
Sys_PopSignalHook ();
new operand handling from nq
2001-02-27 08:21:40 +00:00
return; // all done
Move the signal handling code from video/targets/* to sys.c (I'm leaving the SDL target files for Despair since he's working on the currently). Also make progs segfault handling much more robust (and general: sigill etc too:)
2002-08-20 23:04:57 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_STATE:
really clean up global and function access. Unfortunatly, frames are still borked, at least for the view entity.
2001-03-01 08:34:30 +00:00
ed = PROG_TO_EDICT (pr, *pr->globals.self);
Whitespace.
2001-09-10 12:56:23 +00:00
ed->v[pr->fields.nextthink].float_var = *pr->globals.time +
0.1;
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
ed->v[pr->fields.frame].float_var = OPA.float_var;
ed->v[pr->fields.think].func_var = OPB.func_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
new opcode: state.f. same as state, but takes a 3rd float operand to specify the step for calculating nextthink. accessed using [frame, think, step] (state is [frame, think])
2004-02-11 01:43:33 +00:00
case OP_STATE_F:
ed = PROG_TO_EDICT (pr, *pr->globals.self);
ed->v[pr->fields.nextthink].float_var = *pr->globals.time +
OPC.float_var;
ed->v[pr->fields.frame].float_var = OPA.float_var;
ed->v[pr->fields.think].func_var = OPB.func_var;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_ADD_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var + OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_SUB_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var - OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_MUL_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var * OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
/*
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_DIV_VF:
{
Massive clean up of progs accessors. Just the cleanup of the casts fixed the CustomTF doors issue.
2001-06-07 21:59:24 +00:00
float temp = 1.0f / OPB.float_var;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
VectorScale (OPA.vector_var, temp, OPC.vector_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
break;
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
*/
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_DIV_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var / OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
got a few new operators for qc :) << >> % which all act like their C counterparts += -= *= /= &= ^= |= <<= >>= %= which just expand into the obvious, also like the C versions.
2001-08-10 16:17:00 +00:00
case OP_MOD_I:
OPC.integer_var = OPA.integer_var % OPB.integer_var;
break;
case OP_MOD_F:
OPC.float_var = (int) OPA.float_var % (int) OPB.float_var;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_CONV_IF:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.float_var = OPA.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_CONV_FI:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.float_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_BITAND_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var & OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_BITOR_I:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
OPC.integer_var = OPA.integer_var | OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
^ and ~ operators for qc (^ from Rhamphoryncus) and clean up the punctuation line in qc-lex.l (why didn't I think to do that in the first place?!?)
2001-08-09 16:34:46 +00:00
case OP_BITXOR_I:
OPC.integer_var = OPA.integer_var ^ OPB.integer_var;
break;
case OP_BITNOT_I:
OPC.integer_var = ~OPA.integer_var;
break;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_GE_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_GE_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var >= OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
fix the unsigned comparison opcodes
2003-08-24 05:53:15 +00:00
case OP_GE_U:
OPC.integer_var = OPA.uinteger_var >= OPB.uinteger_var;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_LE_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_LE_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var <= OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
fix the unsigned comparison opcodes
2003-08-24 05:53:15 +00:00
case OP_LE_U:
OPC.integer_var = OPA.uinteger_var <= OPB.uinteger_var;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_GT_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_GT_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var > OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
fix the unsigned comparison opcodes
2003-08-24 05:53:15 +00:00
case OP_GT_U:
OPC.integer_var = OPA.uinteger_var > OPB.uinteger_var;
break;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_LT_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_LT_P:
oops, signage error
2005-05-01 08:30:30 +00:00
OPC.integer_var = OPA.integer_var < OPB.integer_var;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
break;
fix the unsigned comparison opcodes
2003-08-24 05:53:15 +00:00
case OP_LT_U:
OPC.integer_var = OPA.uinteger_var < OPB.uinteger_var;
break;
pr_comp.h: o add ev_uniteger to the types enum o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui progs.h: o add uinteger accessors pr_exec.c: o implement ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui pr_opcode.c: o add opcodes for ifbe, ifb, ifae, ifa, jump, lt.ui, gt.ui, le.ui, ge.ui expr.h: o prototype inc_users qfcc.h: o add externs for op_ifbe, op_ifb, op_ifae and op_ifa emit.c: o don't bother emiting an assignment to a temp def that's only used once (ie, it's never read, only written to) o support the new if* instructions expr.c: o support the new if* insructions o dectect expression loops in append_expr o support unsigned integers o re-work temp def usage counting pr_def.c o debugging for temp def usage counts pr_opcode.c: o support the new if* instructions qc-parse.y: o provide defines for IFBE IFB IFAE IFA switch.c: o do binary searches for strings, floats and ints if there are more than 8 cases in a switch. Strings need more testing.
2001-11-09 00:58:16 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_AND_I:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var && OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_OR_I:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var || OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NOT_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_NOT_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = !OPA.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_EQ_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_EQ_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var == OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
case OP_NE_I:
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
case OP_NE_P:
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
OPC.integer_var = OPA.integer_var != OPB.integer_var;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
break;
Rename move to movei.
2011-03-09 01:28:40 +00:00
case OP_MOVEI:
move the correct amount of bytes (I keep forgetting the * 4 :P)
2002-10-21 16:38:45 +00:00
memmove (&OPC, &OPA, st->b * 4);
two new instructions: move and movep: basicly memmove. qfcc support coming as soon as I get it working :)
2002-10-16 06:44:41 +00:00
break;
case OP_MOVEP:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (pr_boundscheck->int_val) {
PR_BoundsCheckSize (pr, OPC.integer_var, OPB.uinteger_var);
PR_BoundsCheckSize (pr, OPA.integer_var, OPB.uinteger_var);
}
two new instructions: move and movep: basicly memmove. qfcc support coming as soon as I get it working :)
2002-10-16 06:44:41 +00:00
memmove (pr->pr_globals + OPC.integer_var,
move the correct amount of bytes (I keep forgetting the * 4 :P)
2002-10-21 16:38:45 +00:00
pr->pr_globals + OPA.integer_var,
OPB.uinteger_var * 4);
two new instructions: move and movep: basicly memmove. qfcc support coming as soon as I get it working :)
2002-10-16 06:44:41 +00:00
break;
Add a movepi instruction to support indirect moves of fixed size.
2011-03-09 01:29:24 +00:00
case OP_MOVEPI:
if (pr_boundscheck->int_val) {
PR_BoundsCheckSize (pr, OPC.integer_var, st->b);
PR_BoundsCheckSize (pr, OPA.integer_var, st->b);
}
memmove (pr->pr_globals + OPC.integer_var,
pr->pr_globals + OPA.integer_var,
st->b * 4);
break;
two new instructions: move and movep: basicly memmove. qfcc support coming as soon as I get it working :)
2002-10-16 06:44:41 +00:00
Initial integer type support. qfcc /is/ partially broken when it comes to integer constants and float function args/return values. pr_comp.h: o add the integer opcodes to pr_opcode_e pr_edict.c: o add "quaternion" and "integer" to type_name[] o support quatnernion and integers types when printing values o support the integer opcodes when bounds checking pr_exec.c o enable the integer opcodes pr_opcode: o add the integer opcodes to the opcode table o logical operators all result in an integer rather than a value expr.h: o rename int_val to integer_val qfcc.h: o kill another magic number expr.c: o move the opcode to string conversion out of type_mismatch and into get_op_string o rename int_val to integer_val o general integer type support. o generate an internal comipiler error for null opcodes rather than segging. pr_imm.c: o rename int_val to integer_val o support integer constants, converting to float when needed. pr_lex.c: o magic number death and support quaternions and integers in type_size[] qc-lex.l o rename int_val to integer_val o support quaternion and integer type keywords qc-parse.y: o rename int_val to integer_val o use binary_expr instead of new_binary_expr for local initialized variables builtins.c: o rename int_val to integer_val o fix most (all?) of the INT related FIXMEs defs.qc: o use integer instead of float where it makes sense main.c: o read_result is now integer rather than float main.qc: o float -> integer where appropriate o new test for int const to float arg
2001-07-23 01:31:22 +00:00
// LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized
/*
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
case OP_BOUNDCHECK:
rename int_var to integer_var
2001-07-22 20:20:46 +00:00
if (OPA.integer_var < 0 || OPA.integer_var >= st->b) {
Whitespace.
2001-09-10 12:56:23 +00:00
PR_RunError (pr, "Progs boundcheck failed at line number "
search for `.self' before `self'
2002-05-18 00:49:16 +00:00
"%d, value is < 0 or >= %d", st->b, st->c);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
break;
*/
default:
fix up some overzelous s///
2001-06-07 22:15:37 +00:00
PR_RunError (pr, "Bad opcode %i", st->op);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
make the watchpoint (optionally) conditional
2007-05-08 02:25:01 +00:00
if (watch && watch->integer_var != old_val.integer_var
&& (!pr->wp_conditional
|| watch->integer_var == pr->wp_val.integer_var))
"hardware" (haha) watch points (one!) in progs. only catches changes done by progs, and the expression parser is as flaky as anything, but it's better than nothing :)
2007-05-08 02:04:47 +00:00
PR_RunError (pr, "watchpoint hit: %d -> %d", old_val.integer_var,
watch->integer_var);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
Reference in a new issue Copy permalink