eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity

fix while(1)->while(0) issues.

Browse source 
debug evaluation is more verbose (gives field listings when passed an entity).
added string length checks in various places.
sizeof(array) works again.
tweaked fields to be a little more user friendly, and not complain about classes so much when simply using entities.

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@4460 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike 2013-08-21 06:55:54 +00:00
parent 7793b0a73a
commit 803c8c4878
9 changed files with 213 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
engine/qclib/execloop.h
View file

@ -68,7 +68,7 @@ cont: //last statement may have been a breakpoint
break;
case ev_function:
case ev_string:
printf("Watch point hit in %s, \"%s\" now set to %s.\n", PR_StringToNative(&progfuncs->funcs, pr_xfunction->s_name), prinst.watch_name, PR_ValueString(progfuncs, prinst.watch_type, prinst.watch_ptr));
printf("Watch point hit in %s, \"%s\" now set to %s.\n", PR_StringToNative(&progfuncs->funcs, pr_xfunction->s_name), prinst.watch_name, PR_ValueString(progfuncs, prinst.watch_type, prinst.watch_ptr, false));
break;
}
prinst.watch_old = *prinst.watch_ptr;

78
engine/qclib/pr_comp.h
View file

@ -107,55 +107,55 @@ enum qcop_e {
//these following ones are Hexen 2 constants.
OP_MULSTORE_F,
OP_MULSTORE_VF,
OP_MULSTOREP_F,
OP_MULSTOREP_VF,
OP_MULSTORE_F, //66 redundant, for h2 compat
OP_MULSTORE_VF, //67 redundant, for h2 compat
OP_MULSTOREP_F, //68
OP_MULSTOREP_VF,//69
OP_DIVSTORE_F, //70
OP_DIVSTOREP_F,
OP_DIVSTORE_F, //70 redundant, for h2 compat
OP_DIVSTOREP_F, //71
OP_ADDSTORE_F,
OP_ADDSTORE_V,
OP_ADDSTOREP_F,
OP_ADDSTOREP_V,
OP_ADDSTORE_F, //72 redundant, for h2 compat
OP_ADDSTORE_V, //73 redundant, for h2 compat
OP_ADDSTOREP_F, //74
OP_ADDSTOREP_V, //75
OP_SUBSTORE_F,
OP_SUBSTORE_V,
OP_SUBSTOREP_F,
OP_SUBSTOREP_V,
OP_SUBSTORE_F, //76 redundant, for h2 compat
OP_SUBSTORE_V, //77 redundant, for h2 compat
OP_SUBSTOREP_F, //78
OP_SUBSTOREP_V, //79
OP_FETCH_GBL_F, //80
OP_FETCH_GBL_V,
OP_FETCH_GBL_S,
OP_FETCH_GBL_E,
OP_FETCH_GBL_FNC,
OP_FETCH_GBL_V, //81
OP_FETCH_GBL_S, //82
OP_FETCH_GBL_E, //83
OP_FETCH_GBL_FNC,//84
OP_CSTATE,
OP_CWSTATE,
OP_CSTATE, //85
OP_CWSTATE, //86
OP_THINKTIME,
OP_THINKTIME, //87
OP_BITSET,
OP_BITSETP,
OP_BITSET, //88 redundant, for h2 compat
OP_BITSETP, //89
OP_BITCLR, //90
OP_BITCLRP,
OP_BITCLRP, //91
OP_RAND0,
OP_RAND1,
OP_RAND2,
OP_RANDV0,
OP_RANDV1,
OP_RANDV2,
OP_RAND0, //92
OP_RAND1, //93
OP_RAND2, //94
OP_RANDV0, //95
OP_RANDV1, //96
OP_RANDV2, //97
OP_SWITCH_F,
OP_SWITCH_V,
OP_SWITCH_F, //98
OP_SWITCH_V, //99
OP_SWITCH_S, //100
OP_SWITCH_E,
OP_SWITCH_FNC,
OP_SWITCH_E, //101
OP_SWITCH_FNC, //102
OP_CASE,
OP_CASERANGE,
OP_CASE, //103
OP_CASERANGE, //104
@ -286,9 +286,9 @@ enum qcop_e {
OP_GSTOREP_I,
OP_GSTOREP_F,
OP_GSTOREP_ENT,
OP_GSTOREP_FLD, // integers //200
OP_GSTOREP_FLD, //200
OP_GSTOREP_S,
OP_GSTOREP_FNC, // pointers
OP_GSTOREP_FNC,
OP_GSTOREP_V,
OP_GADDRESS,
OP_GLOAD_I,
@ -297,9 +297,9 @@ enum qcop_e {
OP_GLOAD_ENT,
OP_GLOAD_S,
OP_GLOAD_FNC, //210
OP_BOUNDCHECK,
//back to ones that we do use.
OP_BOUNDCHECK,
OP_UNUSED, //used to be OP_STOREP_P, which is now emulated with OP_STOREP_I, fteqcc nor fte generated it
OP_PUSH, //push 4octets onto the local-stack (which is ALWAYS poped on function return). Returns a pointer.
OP_POP, //pop those ones that were pushed (don't over do it). Needs assembler.

148
engine/qclib/pr_edict.c
View file

@ -111,7 +111,7 @@ struct edict_s *PDECL ED_Alloc (pubprogfuncs_t *ppf)
{
int size;
char *buf;
buf = PR_SaveEnts(&progfuncs->funcs, NULL, &size, 0);
buf = PR_SaveEnts(&progfuncs->funcs, NULL, &size, 0, 0);
progfuncs->funcs.parms->WriteFile("edalloc.dump", buf, size);
Sys_Error ("ED_Alloc: no free edicts (max is %i)", maxedicts);
}
@ -465,14 +465,28 @@ dfunction_t *ED_FindFunction (progfuncs_t *progfuncs, char *name, progsnum_t *pr
return NULL;
}
#ifdef _WIN32
static void VARGS QC_snprintfz (char *dest, size_t size, const char *fmt, ...)
{
va_list args;
va_start (args, fmt);
vsnprintf (dest, size-1, fmt, args);
va_end (args);
//make sure its terminated.
dest[size-1] = 0;
}
#else
#define QC_snprintfz snprintf
#endif
/*
============
PR_ValueString
Returns a string describing *data in a human-readable type specific manner
if verbose, contains entity field listing etc too
=============
*/
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val, pbool verbose)
{
static char line[4096];
fdef_t *fielddef;
@ -488,13 +502,13 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
switch (type)
{
case ev_struct:
sprintf (line, "struct");
QC_snprintfz (line, sizeof(line), "struct");
break;
case ev_union:
sprintf (line, "union");
QC_snprintfz (line, sizeof(line), "union");
break;
case ev_string:
sprintf (line, "%s", PR_StringToNative(&progfuncs->funcs, val->string));
QC_snprintfz (line, sizeof(line), "%s", PR_StringToNative(&progfuncs->funcs, val->string));
break;
case ev_entity:
fielddef = ED_FindField(progfuncs, "classname");
@ -504,26 +518,34 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
string_t *v;
ed = (edictrun_t *)EDICT_NUM(progfuncs, val->edict);
v = (string_t *)((char *)edvars(ed) + fielddef->ofs*4);
sprintf (line, "entity %i(%s)", val->edict, PR_StringToNative(&progfuncs->funcs, *v));
QC_snprintfz (line, sizeof(line), "entity %i(%s)", val->edict, PR_StringToNative(&progfuncs->funcs, *v));
}
else
sprintf (line, "entity %i", val->edict);
QC_snprintfz (line, sizeof(line), "entity %i", val->edict);
if (verbose)
{
struct edict_s *ed = EDICT_NUM(progfuncs, val->edict);
int size = strlen(line);
if (ed)
PR_SaveEnt(&progfuncs->funcs, line, &size, sizeof(line), ed);
}
break;
case ev_function:
if (!val->function)
sprintf (line, "NULL function");
QC_snprintfz (line, sizeof(line), "NULL function");
else
{
if ((val->function & 0xff000000)>>24 >= (unsigned)maxprogs || !pr_progstate[(val->function & 0xff000000)>>24].functions)
sprintf (line, "Bad function %i:%i", (val->function & 0xff000000)>>24, val->function & ~0xff000000);
QC_snprintfz (line, sizeof(line), "Bad function %i:%i", (val->function & 0xff000000)>>24, val->function & ~0xff000000);
else
{
if ((val->function &~0xff000000) >= pr_progs->numfunctions)
sprintf(line, "bad function %i:%i\n", (val->function & 0xff000000)>>24, val->function & ~0xff000000);
QC_snprintfz (line, sizeof(line), "bad function %i:%i\n", (val->function & 0xff000000)>>24, val->function & ~0xff000000);
else
{
f = pr_progstate[(val->function & 0xff000000)>>24].functions + (val->function & ~0xff000000);
sprintf (line, "%i:%s()", (val->function & 0xff000000)>>24, f->s_name+progfuncs->funcs.stringtable);
QC_snprintfz (line, sizeof(line), "%i:%s()", (val->function & 0xff000000)>>24, f->s_name+progfuncs->funcs.stringtable);
}
}
}
@ -531,34 +553,34 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
case ev_field:
fielddef = ED_FieldAtOfs (progfuncs, val->_int + progfuncs->funcs.fieldadjust);
if (!fielddef)
sprintf (line, ".??? (%i)", val->_int);
QC_snprintfz (line, sizeof(line), ".??? (%i)", val->_int);
else
sprintf (line, ".%s (%i)", fielddef->name, val->_int);
QC_snprintfz (line, sizeof(line), ".%s (%i)", fielddef->name, val->_int);
break;
case ev_void:
sprintf (line, "void type");
QC_snprintfz (line, sizeof(line), "void type");
break;
case ev_float:
sprintf (line, "%g", val->_float);
QC_snprintfz (line, sizeof(line), "%g", val->_float);
break;
case ev_integer:
sprintf (line, "%i", val->_int);
QC_snprintfz (line, sizeof(line), "%i", val->_int);
break;
case ev_vector:
sprintf (line, "'%g %g %g'", val->_vector[0], val->_vector[1], val->_vector[2]);
QC_snprintfz (line, sizeof(line), "'%g %g %g'", val->_vector[0], val->_vector[1], val->_vector[2]);
break;
case ev_pointer:
sprintf (line, "pointer");
QC_snprintfz (line, sizeof(line), "pointer");
{
// int entnum;
// int valofs;
if (val->_int == 0)
{
sprintf (line, "NULL pointer");
QC_snprintfz (line, sizeof(line), "NULL pointer");
break;
}
//FIXME: :/
sprintf(line, "UNKNOWN");
QC_snprintfz (line, sizeof(line), "UNKNOWN");
// entnum = ((qbyte *)val->edict - (qbyte *)sv_edicts) / pr_edict_size;
// valofs = (int *)val->edict - (int *)edvars(EDICT_NUM(progfuncs, entnum));
// fielddef = ED_FieldAtOfs (progfuncs, valofs );
@ -569,7 +591,7 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
}
break;
default:
sprintf (line, "bad type %i", type);
QC_snprintfz (line, sizeof(line), "bad type %i", type);
break;
}
@ -819,7 +841,7 @@ char *PR_GlobalString (progfuncs_t *progfuncs, int ofs)
sprintf (line,"%i(?""?""?)", ofs);
else
{
s = PR_ValueString (progfuncs, def16->type, val);
s = PR_ValueString (progfuncs, def16->type, val, false);
sprintf (line,"%i(%s)%s", ofs, def16->s_name+progfuncs->funcs.stringtable, s);
}
@ -836,7 +858,7 @@ char *PR_GlobalString (progfuncs_t *progfuncs, int ofs)
sprintf (line,"%i(?""?""?)", ofs);
else
{
s = PR_ValueString (progfuncs, def32->type, val);
s = PR_ValueString (progfuncs, def32->type, val, false);
sprintf (line,"%i(%s)%s", ofs, def32->s_name+progfuncs->funcs.stringtable, s);
}
@ -940,7 +962,7 @@ void PDECL ED_Print (pubprogfuncs_t *ppf, struct edict_s *ed)
while (l++ < 15)
printf (" ");
printf ("%s\n", PR_ValueString(progfuncs, d->type, (eval_t *)v));
printf ("%s\n", PR_ValueString(progfuncs, d->type, (eval_t *)v, false));
}
}
@ -1333,6 +1355,16 @@ cont:
}
#endif
static void PR_Cat(char *out, const char *in, int *len, int max)
{
int newl = strlen(in);
max-=1;
if (*len + newl > max)
newl = max - *len; //truncate
memcpy(out + *len, in, newl+1);
*len += newl;
}
/*
================
ED_LoadFromFile
@ -1349,9 +1381,9 @@ to call ED_CallSpawnFunctions () to let the objects initialize themselves.
================
*/
char *ED_WriteGlobals(progfuncs_t *progfuncs, char *buffer) //switch first.
char *ED_WriteGlobals(progfuncs_t *progfuncs, char *buf, int *bufofs, int bufmax) //switch first.
{
#define AddS(str) strcpy(buffer, str);buffer+=strlen(str);
#define AddS(str) PR_Cat(buf, str, bufofs, bufmax)
int *v;
ddef32_t *def32;
ddef16_t *def16;
@ -1485,13 +1517,14 @@ add32:
Sys_Error("Bad struct type in SaveEnts");
}
return buffer;
return buf;
#undef AddS
}
char *ED_WriteEdict(progfuncs_t *progfuncs, edictrun_t *ed, char *buffer, pbool q1compatible)
char *ED_WriteEdict(progfuncs_t *progfuncs, edictrun_t *ed, char *buf, int *bufofs, int bufmax, pbool q1compatible)
{
#define AddS(str) PR_Cat(buf, str, bufofs, bufmax)
fdef_t *d;
int *v;
unsigned int i;unsigned int j;
char *name;
@ -1531,13 +1564,13 @@ char *ED_WriteEdict(progfuncs_t *progfuncs, edictrun_t *ed, char *buffer, pbool
AddS("\""); AddS(tmp); AddS("\"\n");
}
return buffer;
return buf;
#undef AddS
}
char *SaveCallStack (progfuncs_t *progfuncs, char *s)
char *SaveCallStack (progfuncs_t *progfuncs, char *buf, int *bufofs, int bufmax)
{
#define AddS(str) strcpy(s, str);s+=strlen(str);
#define AddS(str) PR_Cat(buf, str, bufofs, bufmax)
char buffer[8192];
dfunction_t *f;
int i;
@ -1551,7 +1584,7 @@ char *SaveCallStack (progfuncs_t *progfuncs, char *s)
if (pr_depth == 0)
{
AddS ("<NO STACK>\n");
return s;
return buf;
}
globalbase = (int *)pr_globals + pr_xfunction->parm_start + pr_xfunction->locals;
@ -1594,7 +1627,7 @@ char *SaveCallStack (progfuncs_t *progfuncs, char *s)
sprintf(buffer, "\t\t\"%s\" \"entity %i\"\n", local->s_name+progfuncs->funcs.stringtable, ((eval_t*)(globalbase - f->locals+arg))->edict);
}
else
sprintf(buffer, "\t\t\"%s\"\t\"%s\"\n", local->s_name+progfuncs->funcs.stringtable, PR_ValueString(progfuncs, local->type, (eval_t*)(globalbase - f->locals+arg)));
sprintf(buffer, "\t\t\"%s\"\t\"%s\"\n", local->s_name+progfuncs->funcs.stringtable, PR_ValueString(progfuncs, local->type, (eval_t*)(globalbase - f->locals+arg), false));
if (local->type == ev_vector)
arg+=2;
@ -1609,27 +1642,28 @@ char *SaveCallStack (progfuncs_t *progfuncs, char *s)
globalbase -= f->locals;
}
}
return s;
return buf;
#undef AddS
}
//there are two ways of saving everything.
//0 is to save just the entities.
//1 is to save the entites, and all the progs info so that all the variables are saved off, and it can be reloaded to exactly how it was (provided no files or data has been changed outside, like the progs.dat for example)
char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *buf, int *bufofs, int bufmax, int alldata)
{
progfuncs_t *progfuncs = (progfuncs_t*)ppf;
#define AddS(str) strcpy(s, str);s+=strlen(str);
char *s, *os;
#define AddS(str) PR_Cat(buf, str, bufofs, bufmax)
unsigned int a;
char *buffree = NULL;
int oldprogs;
if (mem)
if (!buf)
{
os = s = mem;
if (bufmax <= 0)
bufmax = 5*1024*1024;
buffree = buf = externs->memalloc(bufmax);
}
else
os = s = externs->memalloc(5*1024*1024);
*bufofs = 0;
if (alldata == 2)
{ //special Q1 savegame compatability mode.
@ -1643,7 +1677,7 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
}
if (!pr_progstate[0].progs || a != maxprogs) //the state of the progs wasn't Q1 compatible.
{
externs->memfree(os);
externs->memfree(buffree);
return NULL;
}
@ -1653,7 +1687,7 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
oldprogs = pr_typecurrent;
PR_SwitchProgs(progfuncs, 0);
s = ED_WriteGlobals(progfuncs, s);
ED_WriteGlobals(progfuncs, buf, bufofs, bufmax);
PR_SwitchProgs(progfuncs, oldprogs);
@ -1668,13 +1702,12 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
AddS ("{\n");
if (!ed->isfree)
s = ED_WriteEdict(progfuncs, ed, s, true);
ED_WriteEdict(progfuncs, ed, buf, bufofs, bufmax, true);
AddS ("}\n");
}
*len = s - os;
return os;
return buf;
}
if (alldata)
@ -1707,7 +1740,7 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
{
//include callstack
AddS("stacktrace {\n");
s = SaveCallStack(progfuncs, s);
SaveCallStack(progfuncs, buf, bufofs, bufmax);
AddS("}\n");
}
@ -1720,7 +1753,7 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
PR_SwitchProgs(progfuncs, a);
s = ED_WriteGlobals(progfuncs, s);
ED_WriteGlobals(progfuncs, buf, bufofs, bufmax);
AddS ("}\n");
}
@ -1735,13 +1768,12 @@ char *PDECL PR_SaveEnts(pubprogfuncs_t *ppf, char *mem, int *len, int alldata)
AddS (qcva("entity %i{\n", a));
s = ED_WriteEdict(progfuncs, ed, s, false);
ED_WriteEdict(progfuncs, ed, buf, bufofs, bufmax, false);
AddS ("}\n");
}
*len = s - os;
return os;
return buf;
#undef AddS
}
@ -2263,10 +2295,10 @@ int PDECL PR_LoadEnts(pubprogfuncs_t *ppf, char *file, float killonspawnflags)
return max_fields_size;
}
#define AddS(str) strcpy(s, str);s+=strlen(str);
char *PDECL PR_SaveEnt (pubprogfuncs_t *ppf, char *buf, int *size, struct edict_s *ed)
//FIXME: maxsize is ignored.
char *PDECL PR_SaveEnt (pubprogfuncs_t *ppf, char *buf, int *size, int maxsize, struct edict_s *ed)
{
#define AddS(str) PR_Cat(buf, str, size, maxsize)
progfuncs_t *progfuncs = (progfuncs_t*)ppf;
fdef_t *d;
int *v;
@ -2274,8 +2306,6 @@ char *PDECL PR_SaveEnt (pubprogfuncs_t *ppf, char *buf, int *size, struct edict_
char *name;
int type;
char *s = buf;
// if (ed->free)
// continue;
@ -2289,7 +2319,7 @@ char *PDECL PR_SaveEnt (pubprogfuncs_t *ppf, char *buf, int *size, struct edict_
d = &prinst.field[i];
name = d->name;
len = strlen(name); // should we skip vars with no name?
if (len > 2 && name[len-2] == '_')
if (len > 2 && name[len-2] == '_' && (name[len-1] == 'x' || name[len-1] == 'y' || name[len-1] == 'z'))
continue; // skip _x, _y, _z vars
v = (int*)((edictrun_t*)ed)->fields + d->ofs;
@ -2308,8 +2338,6 @@ char *PDECL PR_SaveEnt (pubprogfuncs_t *ppf, char *buf, int *size, struct edict_
AddS ("}\n");
*size = s - buf;
return buf;
}
struct edict_s *PDECL PR_RestoreEnt (pubprogfuncs_t *ppf, char *buf, int *size, struct edict_s *ed)

21
engine/qclib/pr_exec.c
View file

@ -657,18 +657,20 @@ pbool LocateDebugTerm(progfuncs_t *progfuncs, char *key, eval_t **result, etype_
c2 = COM_TrimString(c2);
def = ED_FindLocalOrGlobal(progfuncs, c2, &fval);
if (def)
if (def && def->type == ev_field)
{
fofs = fval->_int + progfuncs->funcs.fieldadjust;
fdef = ED_FieldAtOfs(progfuncs, fofs);
}
else
{
fdef = ED_FindField(progfuncs, c2);
if (c)*c = '.';
if (!fdef)
return false;
fofs = fdef->ofs;
}
if (c)*c = '.';
if (!fdef)
return false;
fofs = fdef->ofs;
type = fdef->type;
ed = PROG_TO_EDICT(progfuncs, val->_int);
if (!ed)
@ -676,7 +678,6 @@ pbool LocateDebugTerm(progfuncs_t *progfuncs, char *key, eval_t **result, etype_
if (fofs < 0 || fofs >= max_fields_size)
return false;
val = (eval_t *) (((char *)ed->fields) + fofs*4);
type = fdef->type;
}
*rettype = type;
*result = val;
@ -886,7 +887,7 @@ char *PDECL PR_EvaluateDebugString(pubprogfuncs_t *ppf, char *key)
}
assignment[-1] = '=';
}
strcpy(buf, PR_ValueString(progfuncs, type, val));
QC_snprintfz(buf, sizeof(buf), "%s", PR_ValueString(progfuncs, type, val, true));
return buf;
}
@ -1192,7 +1193,7 @@ void PR_ExecuteCode (progfuncs_t *progfuncs, int s)
break;
case ev_function:
case ev_string:
printf("Watch point \"%s\" set by engine to %s.\n", prinst.watch_name, PR_ValueString(progfuncs, prinst.watch_type, prinst.watch_ptr));
printf("Watch point \"%s\" set by engine to %s.\n", prinst.watch_name, PR_ValueString(progfuncs, prinst.watch_type, prinst.watch_ptr, false));
break;
}
prinst.watch_old = *prinst.watch_ptr;

6
engine/qclib/progsint.h
View file

@ -269,9 +269,9 @@ int PDECL Comp_Continue(pubprogfuncs_t *progfuncs);
pbool PDECL PR_SetWatchPoint(pubprogfuncs_t *progfuncs, char *key);
char *PDECL PR_EvaluateDebugString(pubprogfuncs_t *progfuncs, char *key);
char *PDECL PR_SaveEnts(pubprogfuncs_t *progfuncs, char *mem, int *size, int mode);
char *PDECL PR_SaveEnts(pubprogfuncs_t *progfuncs, char *mem, int *size, int maxsize, int mode);
int PDECL PR_LoadEnts(pubprogfuncs_t *progfuncs, char *file, float killonspawnflags);
char *PDECL PR_SaveEnt (pubprogfuncs_t *progfuncs, char *buf, int *size, struct edict_s *ed);
char *PDECL PR_SaveEnt (pubprogfuncs_t *progfuncs, char *buf, int *size, int maxsize, struct edict_s *ed);
struct edict_s *PDECL PR_RestoreEnt (pubprogfuncs_t *progfuncs, char *buf, int *size, struct edict_s *ed);
void PDECL PR_StackTrace (pubprogfuncs_t *progfuncs);
@ -472,7 +472,7 @@ dfunction_t *ED_FindFunction (progfuncs_t *progfuncs, char *name, progsnum_t *pn
func_t PDECL PR_FindFunc(pubprogfuncs_t *progfncs, char *funcname, progsnum_t pnum);
void PDECL PR_Configure (pubprogfuncs_t *progfncs, size_t addressable_size, int max_progs);
int PDECL PR_InitEnts(pubprogfuncs_t *progfncs, int maxents);
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val);
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val, pbool verbose);
void PDECL QC_ClearEdict (pubprogfuncs_t *progfuncs, struct edict_s *ed);
void PRAddressableFlush(progfuncs_t *progfuncs, size_t totalammount);
void QC_FlushProgsOffsets(progfuncs_t *progfuncs);

6
engine/qclib/progslib.h
View file

@ -97,10 +97,10 @@ struct pubprogfuncs_s
char *(PDECL *filefromnewprogs) (pubprogfuncs_t *prinst, char *prname, char *fname, int *size, char *buffer); //reveals encoded/added files from a progs on the disk somewhere
void (PDECL *ED_Print) (pubprogfuncs_t *prinst, struct edict_s *ed);
char *(PDECL *save_ents) (pubprogfuncs_t *prinst, char *buf, int *size, int mode); //dump the entire progs info into one big self allocated string
char *(PDECL *save_ents) (pubprogfuncs_t *prinst, char *buf, int *size, int maxsize, int mode); //dump the entire progs info into one big self allocated string
int (PDECL *load_ents) (pubprogfuncs_t *prinst, char *s, float killonspawnflags); //restore the entire progs state (or just add some more ents) (returns edicts ize)
char *(PDECL *saveent) (pubprogfuncs_t *prinst, char *buf, int *size, struct edict_s *ed); //will save just one entities vars
char *(PDECL *saveent) (pubprogfuncs_t *prinst, char *buf, int *size, int maxsize, struct edict_s *ed); //will save just one entities vars
struct edict_s *(PDECL *restoreent) (pubprogfuncs_t *prinst, char *buf, int *size, struct edict_s *ed); //will restore the entity that had it's values saved (can use NULL for ed)
union eval_s *(PDECL *FindGlobal) (pubprogfuncs_t *prinst, char *name, progsnum_t num, etype_t *type); //find a pointer to the globals value
@ -251,7 +251,7 @@ typedef union eval_s
#define ED_Clear(pf, ed) (*pf->EntClear) (pf, ed)
#define PR_LoadEnts(pf, s, kf) (*pf->load_ents) (pf, s, kf)
#define PR_SaveEnts(pf, buf, size, mode) (*pf->save_ents) (pf, buf, size, mode)
#define PR_SaveEnts(pf, buf, size, maxsize, mode) (*pf->save_ents) (pf, buf, size, maxsize, mode)
#define EDICT_NUM(pf, num) (*pf->EDICT_NUM) (pf, num)
#define NUM_FOR_EDICT(pf, e) (*pf->NUM_FOR_EDICT) (pf, e)

1
engine/qclib/qcc.h
View file

@ -649,6 +649,7 @@ enum {
WARN_MISSINGOPTIONAL,
WARN_SYSTEMCRC,
WARN_CONDITIONALTYPEMISMATCH,
WARN_MISSINGMEMBERQUALIFIER,//virtual/static/nonvirtual qualifier is missing
WARN_SELFNOTTHIS, //warned for because 'self' does not have the right type. we convert such references to 'this' instead, which is more usable.
WARN_EVILPREPROCESSOR, //exploited by nexuiz, and generally unsafe.
WARN_UNARYNOTSCOPE, //!foo & bar the ! applies to the result of &. This is unlike C.

51
engine/qclib/qcc_pr_comp.c
View file

@ -140,8 +140,8 @@ QCC_type_t *QCC_PR_FindType (QCC_type_t *type);
QCC_type_t *QCC_PR_PointerType (QCC_type_t *pointsto);
QCC_type_t *QCC_PR_FieldType (QCC_type_t *pointsto);
QCC_def_t *QCC_PR_Term (int exprflags);
QCC_def_t *QCC_PR_ParseValue (QCC_type_t *assumeclass, pbool allowarrayassign, pbool expandmemberfields);
QCC_def_t *QCC_PR_ParseArrayPointer (QCC_def_t *d, pbool allowarrayassign);
QCC_def_t *QCC_PR_ParseValue (QCC_type_t *assumeclass, pbool allowarrayassign, pbool expandmemberfields, pbool makearraypointers);
QCC_def_t *QCC_PR_ParseArrayPointer (QCC_def_t *d, pbool allowarrayassign, pbool makestructpointers);
QCC_def_t *QCC_PR_GenerateFunctionCall (QCC_def_t *newself, QCC_def_t *func, QCC_def_t *arglist[], QCC_type_t *argtypelist[], int argcount);
void QCC_Marshal_Locals(int firststatement, int laststatement);
@ -3344,7 +3344,7 @@ QCC_def_t *QCC_PR_ParseFunctionCall (QCC_def_t *newself, QCC_def_t *func) //warn
{
int sz;
int oldstcount = numstatements;
e = QCC_PR_Expression (TOP_PRIORITY, EXPR_DISALLOW_COMMA);
e = QCC_PR_ParseValue(pr_classtype, false, true, false);
//the term should not have side effects, or generate any actual statements.
numstatements = oldstcount;
QCC_PR_Expect(")");
@ -3770,7 +3770,7 @@ QCC_def_t *QCC_PR_ParseFunctionCall (QCC_def_t *newself, QCC_def_t *func) //warn
while(QCC_PR_CheckToken(","))
{
QCC_def_t *f, *p, *v;
f = QCC_PR_ParseValue(rettype, false, false);
f = QCC_PR_ParseValue(rettype, false, false, true);
if (f->type->type != ev_field)
QCC_PR_ParseError(0, "Named field is not a field.");
if (QCC_PR_CheckToken("=")) //allow : or = as a separator, but throw a warning for =
@ -4591,7 +4591,7 @@ static QCC_def_t *QCC_PR_ExpandField(QCC_def_t *ent, QCC_def_t *field)
QCC_PR_SimpleStatement(OP_LOAD_FNC, nthis->ofs, field->ofs, func->ofs, false);
qcc_usefulstatement=true;
r = QCC_PR_ParseFunctionCall(nthis, func);
r = QCC_PR_ParseArrayPointer(r, true);
r = QCC_PR_ParseArrayPointer(r, true, true);
}
else
{
@ -4630,11 +4630,16 @@ static QCC_def_t *QCC_PR_ParseField(QCC_def_t *d)
QCC_PR_Expect(")");
}
else
field = QCC_PR_ParseValue(d->type, false, false);
field = QCC_PR_ParseValue(d->type, false, false, true);
if (field->type->type == ev_field || field->type->type == ev_variant)
d = QCC_PR_ExpandField(d, field);
else
QCC_PR_ParseError(ERR_INTERNAL, "Bad field type of class %s", d->type->name);
{
if (d->type->parentclass)
QCC_PR_ParseError(ERR_INTERNAL, "%s is not a field of class %s", field->name, d->type->name);
else
QCC_PR_ParseError(ERR_INTERNAL, "%s is not a field", field->name);
}
d = QCC_PR_ParseField(d);
}
@ -4649,7 +4654,7 @@ within types which are a contiguous block, expanding to an array index.
Also calls QCC_PR_ParseField, which does fields too.
*/
QCC_def_t *QCC_PR_ParseArrayPointer (QCC_def_t *d, pbool allowarrayassign)
QCC_def_t *QCC_PR_ParseArrayPointer (QCC_def_t *d, pbool allowarrayassign, pbool makearraypointers)
{
QCC_type_t *t;
QCC_def_t *idx;
@ -5068,11 +5073,11 @@ QCC_def_t *QCC_PR_ParseArrayPointer (QCC_def_t *d, pbool allowarrayassign)
}
/*parse recursively*/
d = QCC_PR_ParseArrayPointer(d, allowarrayassign);
d = QCC_PR_ParseArrayPointer(d, allowarrayassign, makearraypointers);
}
//float b[64]; return b; should return a pointer, and NOT the value b[0].
if (arraysize)
if (arraysize && makearraypointers)
d = QCC_PR_GenerateAddressOf(statatementstart, d);
d = QCC_PR_ParseField(d);
@ -5086,7 +5091,7 @@ PR_ParseValue
Returns the global ofs for the current token
============
*/
QCC_def_t *QCC_PR_ParseValue (QCC_type_t *assumeclass, pbool allowarrayassign, pbool expandmemberfields)
QCC_def_t *QCC_PR_ParseValue (QCC_type_t *assumeclass, pbool allowarrayassign, pbool expandmemberfields, pbool makearraypointers)
{
QCC_def_t *d, *od;
QCC_type_t *t;
@ -5316,7 +5321,7 @@ QCC_def_t *QCC_PR_ParseValue (QCC_type_t *assumeclass, pbool allowarrayassign, p
QCC_PR_ParseWarning (WARN_SELFNOTTHIS, "'self' used inside OO function, use 'this'.", pr_scope->name);
}
d = QCC_PR_ParseArrayPointer(d, allowarrayassign);
d = QCC_PR_ParseArrayPointer(d, allowarrayassign, makearraypointers);
if (pr_classtype && expandmemberfields && d->type->type == ev_field)
{
@ -5602,12 +5607,12 @@ QCC_def_t *QCC_PR_Term (int exprflags)
QCC_PR_Expect (")");
conditional = oldcond;
QCC_PR_ParseArrayPointer(e, true);
QCC_PR_ParseArrayPointer(e, true, true);
}
return e;
}
}
return QCC_PR_ParseValue (pr_classtype, !(exprflags&EXPR_DISALLOW_ARRAYASSIGN), true);
return QCC_PR_ParseValue (pr_classtype, !(exprflags&EXPR_DISALLOW_ARRAYASSIGN), true, true);
}
@ -5679,7 +5684,7 @@ QCC_def_t *QCC_PR_Expression (int priority, int exprflags)
{
qcc_usefulstatement=true;
e = QCC_PR_ParseFunctionCall (NULL, e);
e = QCC_PR_ParseArrayPointer(e, true);
e = QCC_PR_ParseArrayPointer(e, true, true);
}
if (QCC_PR_CheckToken ("?"))
{
@ -6365,7 +6370,7 @@ void QCC_PR_ParseStatement (void)
if (((e->constant && !e->temp) || !STRCMP(e->name, "IMMEDIATE")) && opt_compound_jumps)
{
optres_compound_jumps++;
if (!G_INT(e->ofs) == wasuntil)
if (!G_INT(e->ofs) != wasuntil)
{
QCC_PR_ParseWarning(0, "while(0)?");
QCC_FreeTemp(QCC_PR_Statement (&pr_opcodes[OP_GOTO], 0, 0, &patch1));
@ -6379,7 +6384,7 @@ void QCC_PR_ParseStatement (void)
{
if (e->constant && !e->temp)
{
if (!G_FLOAT(e->ofs) == wasuntil)
if (!G_FLOAT(e->ofs) != wasuntil)
QCC_FreeTemp(QCC_PR_Statement (&pr_opcodes[OP_GOTO], 0, 0, &patch1));
else
patch1 = NULL;
@ -7323,7 +7328,7 @@ void QCC_PR_ParseAsm(void)
{
patch1 = &statements[numstatements];
a = QCC_PR_ParseValue(pr_classtype, false, false);
a = QCC_PR_ParseValue(pr_classtype, false, false, true);
QCC_PR_Statement3(&pr_opcodes[op], a, NULL, NULL, true);
if (pr_token_type == tt_name)
@ -7342,8 +7347,8 @@ void QCC_PR_ParseAsm(void)
{
patch1 = &statements[numstatements];
a = QCC_PR_ParseValue(pr_classtype, false, false);
b = QCC_PR_ParseValue(pr_classtype, false, false);
a = QCC_PR_ParseValue(pr_classtype, false, false, true);
b = QCC_PR_ParseValue(pr_classtype, false, false, true);
QCC_PR_Statement3(&pr_opcodes[op], a, b, NULL, true);
if (pr_token_type == tt_name)
@ -7362,15 +7367,15 @@ void QCC_PR_ParseAsm(void)
else
{
if (pr_opcodes[op].type_a != &type_void)
a = QCC_PR_ParseValue(pr_classtype, false, false);
a = QCC_PR_ParseValue(pr_classtype, false, false, true);
else
a=NULL;
if (pr_opcodes[op].type_b != &type_void)
b = QCC_PR_ParseValue(pr_classtype, false, false);
b = QCC_PR_ParseValue(pr_classtype, false, false, true);
else
b=NULL;
if (pr_opcodes[op].associative==ASSOC_LEFT && pr_opcodes[op].type_c != &type_void)
c = QCC_PR_ParseValue(pr_classtype, false, false);
c = QCC_PR_ParseValue(pr_classtype, false, false, true);
else
c=NULL;

51
engine/qclib/qcc_pr_lex.c
View file

@ -3963,11 +3963,20 @@ QCC_type_t *QCC_PR_ParseType (int newtype, pbool silentfail)
while (!QCC_PR_CheckToken("}"))
{
pbool havebody = false;
pbool isstatic = false, isvirt = false;
if (QCC_PR_CheckKeyword(1, "static"))
isstatic = true;
if (QCC_PR_CheckKeyword(1, "virtual"))
isvirt = true;
pbool isvirt = false;
pbool isnonvirt = false;
pbool isstatic = false;
while(1)
{
if (QCC_PR_CheckKeyword(1, "nonvirtual"))
isnonvirt = true;
else if (QCC_PR_CheckKeyword(1, "static"))
isstatic = true;
else if (QCC_PR_CheckKeyword(1, "virtual"))
isvirt = true;
else
break;
}
newparm = QCC_PR_ParseType(false, false);
if (!newparm)
@ -3976,9 +3985,7 @@ QCC_type_t *QCC_PR_ParseType (int newtype, pbool silentfail)
if (newparm->type == ev_struct || newparm->type == ev_union) //we wouldn't be able to handle it.
QCC_PR_ParseError(ERR_INTERNAL, "Struct or union in class %s", classname);
parmname = qccHunkAlloc(strlen(pr_token)+1);
strcpy(parmname, pr_token);
QCC_PR_Lex();
parmname = QCC_PR_ParseName();
if (QCC_PR_CheckToken("["))
{
arraysize = QCC_PR_IntConstExpr();
@ -3987,9 +3994,30 @@ QCC_type_t *QCC_PR_ParseType (int newtype, pbool silentfail)
else
arraysize = 0;
if (isvirt && newparm->type != ev_function)
if (newparm->type == ev_function)
{
QCC_Error(ERR_INTERNAL, "virtual keyword on member that is not a function");
if (isstatic)
QCC_PR_ParseError(ERR_INTERNAL, "%s::%s static functions are not supported at this time.", classname, parmname);
if (!strcmp(classname, parmname))
{
if (isstatic)
QCC_PR_ParseError(ERR_INTERNAL, "Constructor %s::%s may not be static.", classname, pr_token);
if (!isvirt)
isnonvirt = true;//silently promote constructors to nonvirt
}
else if (!isvirt && !isnonvirt && !isstatic)
{
QCC_PR_ParseWarning(WARN_MISSINGMEMBERQUALIFIER, "%s::%s was not qualified. Assuming non-virtual.", classname, parmname);
isnonvirt = true;
}
if (isvirt+isnonvirt+isstatic != 1)
QCC_PR_ParseError(ERR_INTERNAL, "Multiple conflicting qualifiers on %s::%s.", classname, pr_token);
}
else
{
if (isvirt|isnonvirt)
QCC_Error(ERR_INTERNAL, "virtual keyword on member that is not a function");
}
if (newparm->type == ev_function)
@ -4078,12 +4106,11 @@ QCC_type_t *QCC_PR_ParseType (int newtype, pbool silentfail)
}
}
if (!isvirt && !isstatic)
if (!isvirt)
{
QCC_def_t *fdef;
QCC_type_t *pc;
unsigned int i;
isstatic = true; //assume static if its initialised inside the function.
for (pc = newt->parentclass; pc; pc = pc->parentclass)
{