prvm_eval_t prvm_badvalue; // used only for error returns
-cvar_t prvm_language = {CVAR_SAVE, "prvm_language", "", "when set, loads progs.dat.LANGUAGENAME.po for string translations; when set to dump, progs.dat.pot is written from the strings in the progs"};
-// LordHavoc: prints every opcode as it executes - warning: this is significant spew
-cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};
-// LordHavoc: counts usage of each QuakeC statement
-cvar_t prvm_statementprofiling = {0, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"};
-cvar_t prvm_timeprofiling = {0, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"};
-cvar_t prvm_backtraceforwarnings = {0, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"};
-cvar_t prvm_leaktest = {0, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"};
-cvar_t prvm_leaktest_ignore_classnames = {0, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"};
-cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"};
-cvar_t prvm_reuseedicts_startuptime = {0, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"};
-cvar_t prvm_reuseedicts_neverinsameframe = {0, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"};
+cvar_t prvm_language = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "prvm_language", "", "when set, loads PROGSFILE.LANGUAGENAME.po and common.LANGUAGENAME.po for string translations; when set to dump, PROGSFILE.pot is written from the strings in the progs"};
+// LadyHavoc: prints every opcode as it executes - warning: this is significant spew
+cvar_t prvm_traceqc = {CF_CLIENT | CF_SERVER, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};
+// LadyHavoc: counts usage of each QuakeC statement
+cvar_t prvm_statementprofiling = {CF_CLIENT | CF_SERVER, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"};
+cvar_t prvm_timeprofiling = {CF_CLIENT | CF_SERVER, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"};
+cvar_t prvm_coverage = {CF_CLIENT | CF_SERVER, "prvm_coverage", "0", "report and count coverage events (1: per-function, 2: coverage() builtin, 4: per-statement)"};
+cvar_t prvm_backtraceforwarnings = {CF_CLIENT | CF_SERVER, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"};
+cvar_t prvm_leaktest = {CF_CLIENT | CF_SERVER, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"};
+cvar_t prvm_leaktest_follow_targetname = {CF_CLIENT | CF_SERVER, "prvm_leaktest_follow_targetname", "0", "if set, target/targetname links are considered when leak testing; this should normally not be required, as entities created during startup - e.g. info_notnull - are never considered leaky"};
+cvar_t prvm_leaktest_ignore_classnames = {CF_CLIENT | CF_SERVER, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"};
+cvar_t prvm_errordump = {CF_CLIENT | CF_SERVER, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"};
+cvar_t prvm_breakpointdump = {CF_CLIENT | CF_SERVER, "prvm_breakpointdump", "0", "write a savegame on breakpoint to breakpoint-server.dmp"};
+cvar_t prvm_reuseedicts_startuptime = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"};
+cvar_t prvm_reuseedicts_neverinsameframe = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"};
+cvar_t prvm_garbagecollection_enable = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_enable", "1", "automatically scan for and free resources that are not referenced by the code being executed in the VM"};
+cvar_t prvm_garbagecollection_notify = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_notify", "0", "print out a notification for each resource freed by garbage collection"};
+cvar_t prvm_garbagecollection_scan_limit = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_scan_limit", "10000", "scan this many fields or resources per frame to free up unreferenced resources"};
+cvar_t prvm_garbagecollection_strings = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_strings", "1", "automatically call strunzone() on strings that are not referenced"};
+cvar_t prvm_stringdebug = {CF_CLIENT | CF_SERVER, "prvm_stringdebug", "0", "Print debug and warning messages related to strings"};
static double prvm_reuseedicts_always_allow = 0;
-qboolean prvm_runawaycheck = true;
+qbool prvm_runawaycheck = true;
//============================================================================
// mempool handling
// alloc edict fields
prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
- prog->edictsfields = (vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(vec_t));
+ prog->edictsfields.fp = (prvm_vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(prvm_vec_t));
// set edict pointers
for(i = 0; i < prog->max_edicts; i++)
{
prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char *)prog->edictprivate + i * prog->edictprivate_size);
- prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
+ prog->edicts[i].fields.fp = prog->edictsfields.fp + i * prog->entityfields;
}
}
prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
- prog->edictsfields = (vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields, prog->entityfieldsarea * sizeof(vec_t));
+ prog->edictsfields.fp = (prvm_vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields.fp, prog->entityfieldsarea * sizeof(prvm_vec_t));
prog->edictprivate = (void *)Mem_Realloc(prog->progs_mempool, (void *)prog->edictprivate, prog->max_edicts * prog->edictprivate_size);
//set e and v pointers
for(i = 0; i < prog->max_edicts; i++)
{
prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char *)prog->edictprivate + i * prog->edictprivate_size);
- prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
+ prog->edicts[i].fields.fp = prog->edictsfields.fp + i * prog->entityfields;
}
prog->end_increase_edicts(prog);
int PRVM_ED_FindFieldOffset(prvm_prog_t *prog, const char *field)
{
- ddef_t *d;
+ mdef_t *d;
d = PRVM_ED_FindField(prog, field);
if (!d)
return -1;
int PRVM_ED_FindGlobalOffset(prvm_prog_t *prog, const char *global)
{
- ddef_t *d;
+ mdef_t *d;
d = PRVM_ED_FindGlobal(prog, global);
if (!d)
return -1;
return SVVM_prog;
if (!strcmp(str, "client"))
return CLVM_prog;
+#ifdef CONFIG_MENU
if (!strcmp(str, "menu"))
return MVM_prog;
+#endif
return NULL;
}
=================
PRVM_ED_ClearEdict
-Sets everything to NULL
+Sets everything to NULL.
+
+Nota bene: this also marks the entity as allocated if it has been previously
+freed and sets the allocation origin.
=================
*/
void PRVM_ED_ClearEdict(prvm_prog_t *prog, prvm_edict_t *e)
{
- memset(e->fields.vp, 0, prog->entityfields * 4);
- e->priv.required->free = false;
+ memset(e->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
+ e->free = false;
+ e->freetime = host.realtime;
+ if(e->priv.required->allocation_origin)
+ Mem_Free((char *)e->priv.required->allocation_origin);
+ e->priv.required->allocation_origin = PRVM_AllocationOrigin(prog);
// AK: Let the init_edict function determine if something needs to be initialized
prog->init_edict(prog, e);
if(prog->leaktest_active)
if(prog->depth > 0) // actually in QC code and not just parsing the entities block of a map/savegame
{
- buf = (char *)PRVM_Alloc(128);
- PRVM_ShortStackTrace(prog, buf, 128);
+ buf = (char *)PRVM_Alloc(256);
+ PRVM_ShortStackTrace(prog, buf, 256);
}
return buf;
}
Returns if this particular edict could get allocated by PRVM_ED_Alloc
=================
*/
-qboolean PRVM_ED_CanAlloc(prvm_prog_t *prog, prvm_edict_t *e)
+qbool PRVM_ED_CanAlloc(prvm_prog_t *prog, prvm_edict_t *e)
{
- if(!e->priv.required->free)
+ if(!e->free)
return false;
- if(prvm_reuseedicts_always_allow == realtime)
+ if(prvm_reuseedicts_always_allow == host.realtime)
return true;
- if(realtime <= e->priv.required->freetime + 0.1 && prvm_reuseedicts_neverinsameframe.integer)
+ if(host.realtime <= e->freetime + 0.1 && prvm_reuseedicts_neverinsameframe.integer)
return false; // never allow reuse in same frame (causes networking trouble)
- if(e->priv.required->freetime < prog->starttime + prvm_reuseedicts_startuptime.value)
+ if(e->freetime < prog->starttime + prvm_reuseedicts_startuptime.value)
return true;
- if(realtime > e->priv.required->freetime + 1)
+ if(host.realtime > e->freetime + 1)
return true;
return false; // entity slot still blocked because the entity was freed less than one second ago
}
if(PRVM_ED_CanAlloc(prog, e))
{
PRVM_ED_ClearEdict (prog, e);
- e->priv.required->allocation_origin = PRVM_AllocationOrigin(prog);
return e;
}
}
PRVM_MEM_IncreaseEdicts(prog);
e = PRVM_EDICT_NUM(i);
- PRVM_ED_ClearEdict(prog, e);
-
- e->priv.required->allocation_origin = PRVM_AllocationOrigin(prog);
+ PRVM_ED_ClearEdict(prog, e);
return e;
}
PRVM_ED_Free
Marks the edict as free
+
FIXME: walk all entities and NULL out references to this entity
+bones_was_here: do not want, that would break chains immediately!
+Currently chains aren't broken by removing an entity, at least with prvm_reuseedicts_neverinsameframe 1
+which is very handy and some QC code will depend on it.
=================
*/
void PRVM_ED_Free(prvm_prog_t *prog, prvm_edict_t *ed)
prog->free_edict(prog, ed);
- ed->priv.required->free = true;
- ed->priv.required->freetime = realtime;
+ ed->free = true;
+ ed->freetime = host.realtime;
if(ed->priv.required->allocation_origin)
{
Mem_Free((char *)ed->priv.required->allocation_origin);
PRVM_ED_GlobalAtOfs
============
*/
-static ddef_t *PRVM_ED_GlobalAtOfs (prvm_prog_t *prog, int ofs)
+static mdef_t *PRVM_ED_GlobalAtOfs (prvm_prog_t *prog, unsigned int ofs)
{
- ddef_t *def;
+ mdef_t *def;
int i;
for (i = 0;i < prog->numglobaldefs;i++)
PRVM_ED_FieldAtOfs
============
*/
-ddef_t *PRVM_ED_FieldAtOfs (prvm_prog_t *prog, int ofs)
+mdef_t *PRVM_ED_FieldAtOfs (prvm_prog_t *prog, unsigned int ofs)
{
- ddef_t *def;
+ mdef_t *def;
int i;
for (i = 0;i < prog->numfielddefs;i++)
PRVM_ED_FindField
============
*/
-ddef_t *PRVM_ED_FindField (prvm_prog_t *prog, const char *name)
+mdef_t *PRVM_ED_FindField (prvm_prog_t *prog, const char *name)
{
- ddef_t *def;
+ mdef_t *def;
int i;
for (i = 0;i < prog->numfielddefs;i++)
PRVM_ED_FindGlobal
============
*/
-ddef_t *PRVM_ED_FindGlobal (prvm_prog_t *prog, const char *name)
+mdef_t *PRVM_ED_FindGlobal (prvm_prog_t *prog, const char *name)
{
- ddef_t *def;
+ mdef_t *def;
int i;
for (i = 0;i < prog->numglobaldefs;i++)
return NULL;
}
+/*
+============
+PRVM_ED_FindGlobalEval
+============
+*/
+prvm_eval_t *PRVM_ED_FindGlobalEval(prvm_prog_t *prog, const char *name)
+{
+ mdef_t *def = PRVM_ED_FindGlobal(prog, name);
+ return def ? (prvm_eval_t *) &prog->globals.fp[def->ofs] : NULL;
+}
/*
============
*/
static char *PRVM_ValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, char *line, size_t linelength)
{
- ddef_t *def;
+ mdef_t *def;
mfunction_t *f;
int n;
dpsnprintf (line, linelength, "entity %i", n);
break;
case ev_function:
- f = prog->functions + val->function;
- dpsnprintf (line, linelength, "%s()", PRVM_GetString(prog, f->s_name));
+ if ((unsigned int)val->function < (unsigned int)prog->progs_numfunctions)
+ {
+ f = prog->functions + val->function;
+ dpsnprintf (line, linelength, "%s()", PRVM_GetString(prog, f->s_name));
+ }
+ else
+ dpsnprintf (line, linelength, "function %" PRVM_PRIi "() (invalid!)", val->function);
break;
case ev_field:
def = PRVM_ED_FieldAtOfs ( prog, val->_int );
- dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
+ if (def != NULL)
+ dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
+ else
+ dpsnprintf (line, linelength, "field %" PRVM_PRIi " (invalid!)", val->_int );
break;
case ev_void:
dpsnprintf (line, linelength, "void");
break;
case ev_float:
- // LordHavoc: changed from %5.1f to %10.4f
- dpsnprintf (line, linelength, "%10.4f", val->_float);
+ // LadyHavoc: changed from %5.1f to %10.4f
+ dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float);
break;
case ev_vector:
- // LordHavoc: changed from %5.1f to %10.4f
- dpsnprintf (line, linelength, "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
+ // LadyHavoc: changed from %5.1f to %10.4f
+ dpsnprintf (line, linelength, "'" PRVM_VECTOR_LOSSLESS_FORMAT "'", val->vector[0], val->vector[1], val->vector[2]);
break;
case ev_pointer:
dpsnprintf (line, linelength, "pointer");
{
int i;
const char *s;
- ddef_t *def;
+ mdef_t *def;
mfunction_t *f;
type = (etype_t)((int)type & ~DEF_SAVEGLOBAL);
line[i] = '\0';
break;
case ev_entity:
- dpsnprintf (line, linelength, "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
+ i = val->edict;
+ dpsnprintf (line, linelength, "%i", i);
break;
case ev_function:
- f = prog->functions + val->function;
- strlcpy (line, PRVM_GetString (prog, f->s_name), linelength);
+ if ((unsigned int)val->function < (unsigned int)prog->progs_numfunctions)
+ {
+ f = prog->functions + val->function;
+ strlcpy (line, PRVM_GetString (prog, f->s_name), linelength);
+ }
+ else
+ dpsnprintf (line, linelength, "bad function %" PRVM_PRIi " (invalid!)", val->function);
break;
case ev_field:
def = PRVM_ED_FieldAtOfs ( prog, val->_int );
- dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
+ if (def != NULL)
+ dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
+ else
+ dpsnprintf (line, linelength, "field %" PRVM_PRIi "(invalid!)", val->_int );
break;
case ev_void:
dpsnprintf (line, linelength, "void");
break;
case ev_float:
- dpsnprintf (line, linelength, "%.9g", val->_float);
+ dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float);
break;
case ev_vector:
- dpsnprintf (line, linelength, "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]);
+ dpsnprintf (line, linelength, PRVM_VECTOR_LOSSLESS_FORMAT, val->vector[0], val->vector[1], val->vector[2]);
break;
default:
dpsnprintf (line, linelength, "bad type %i", type);
{
char *s;
//size_t i;
- ddef_t *def;
- void *val;
+ mdef_t *def;
+ prvm_eval_t *val;
char valuebuf[MAX_INPUTLINE];
- val = (void *)&prog->globals.generic[ofs];
+ val = (prvm_eval_t *)&prog->globals.fp[ofs];
def = PRVM_ED_GlobalAtOfs(prog, ofs);
if (!def)
dpsnprintf (line, linelength, "GLOBAL%i", ofs);
else
{
- s = PRVM_ValueString (prog, (etype_t)def->type, (prvm_eval_t *)val, valuebuf, sizeof(valuebuf));
+ s = PRVM_ValueString (prog, (etype_t)def->type, val, valuebuf, sizeof(valuebuf));
dpsnprintf (line, linelength, "%s (=%s)", PRVM_GetString(prog, def->s_name), s);
}
char *PRVM_GlobalStringNoContents (prvm_prog_t *prog, int ofs, char *line, size_t linelength)
{
//size_t i;
- ddef_t *def;
+ mdef_t *def;
def = PRVM_ED_GlobalAtOfs(prog, ofs);
if (!def)
For debugging
=============
*/
-// LordHavoc: optimized this to print out much more quickly (tempstring)
-// LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
+// LadyHavoc: optimized this to print out much more quickly (tempstring)
+// LadyHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
void PRVM_ED_Print(prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fieldname)
{
size_t l;
- ddef_t *d;
- int *v;
+ mdef_t *d;
+ prvm_eval_t *val;
int i, j;
const char *name;
int type;
char tempstring[MAX_INPUTLINE], tempstring2[260]; // temporary string buffers
char valuebuf[MAX_INPUTLINE];
- if (ed->priv.required->free)
+ if (ed->free)
{
Con_Printf("%s: FREE\n",prog->name);
return;
// Didn't match; skip
continue;
- v = (int *)(ed->fields.vp + d->ofs);
+ val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
// if the value is still all 0, skip the field
type = d->type & ~DEF_SAVEGLOBAL;
for (j=0 ; j<prvm_type_size[type] ; j++)
- if (v[j])
+ if (val->ivector[j])
break;
if (j == prvm_type_size[type])
continue;
strlcat(tempstring, " ", sizeof(tempstring));
strlcat(tempstring, " ", sizeof(tempstring));
- name = PRVM_ValueString(prog, (etype_t)d->type, (prvm_eval_t *)v, valuebuf, sizeof(valuebuf));
+ name = PRVM_ValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf));
if (strlen(name) > sizeof(tempstring2)-4)
{
memcpy (tempstring2, name, sizeof(tempstring2)-4);
For savegames
=============
*/
-extern cvar_t developer_entityparsing;
void PRVM_ED_Write (prvm_prog_t *prog, qfile_t *f, prvm_edict_t *ed)
{
- ddef_t *d;
- int *v;
+ mdef_t *d;
+ prvm_eval_t *val;
int i, j;
const char *name;
int type;
FS_Print(f, "{\n");
- if (ed->priv.required->free)
+ if (ed->free)
{
FS_Print(f, "}\n");
return;
if(strlen(name) > 1 && name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars, and ALSO other _? vars as some mods expect them to be never saved (TODO: a gameplayfix for using the "more precise" condition above?)
- v = (int *)(ed->fields.vp + d->ofs);
+ val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
// if the value is still all 0, skip the field
type = d->type & ~DEF_SAVEGLOBAL;
for (j=0 ; j<prvm_type_size[type] ; j++)
- if (v[j])
+ if (val->ivector[j])
break;
if (j == prvm_type_size[type])
continue;
FS_Printf(f,"\"%s\" ",name);
prog->statestring = va(vabuf, sizeof(vabuf), "PRVM_ED_Write, ent=%d, name=%s", i, name);
- FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)d->type, (prvm_eval_t *)v, valuebuf, sizeof(valuebuf)));
+ FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf)));
prog->statestring = NULL;
}
For debugging, prints all the entities in the current server
=============
*/
-void PRVM_ED_PrintEdicts_f (void)
+void PRVM_ED_PrintEdicts_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
int i;
const char *wildcard_fieldname;
- if(Cmd_Argc() < 2 || Cmd_Argc() > 3)
+ if(Cmd_Argc(cmd) < 2 || Cmd_Argc(cmd) > 3)
{
Con_Print("prvm_edicts <program name> <optional field name wildcard>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- if( Cmd_Argc() == 3)
- wildcard_fieldname = Cmd_Argv(2);
+ if( Cmd_Argc(cmd) == 3)
+ wildcard_fieldname = Cmd_Argv(cmd, 2);
else
wildcard_fieldname = NULL;
For debugging, prints a single edict
=============
*/
-static void PRVM_ED_PrintEdict_f (void)
+static void PRVM_ED_PrintEdict_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
int i;
const char *wildcard_fieldname;
- if(Cmd_Argc() < 3 || Cmd_Argc() > 4)
+ if(Cmd_Argc(cmd) < 3 || Cmd_Argc(cmd) > 4)
{
Con_Print("prvm_edict <program name> <edict number> <optional field name wildcard>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- i = atoi (Cmd_Argv(2));
+ i = atoi (Cmd_Argv(cmd, 2));
if (i >= prog->num_edicts)
{
Con_Print("Bad edict number\n");
return;
}
- if( Cmd_Argc() == 4)
+ if( Cmd_Argc(cmd) == 4)
// Optional Wildcard Provided
- wildcard_fieldname = Cmd_Argv(3);
+ wildcard_fieldname = Cmd_Argv(cmd, 3);
else
// Use All
wildcard_fieldname = NULL;
*/
// 2 possibilities : 1. just displaying the active edict count
// 2. making a function pointer [x]
-static void PRVM_ED_Count_f (void)
+static void PRVM_ED_Count_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
- if(Cmd_Argc() != 2)
+ if(Cmd_Argc(cmd) != 2)
{
Con_Print("prvm_count <program name>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
prog->count_edicts(prog);
*/
void PRVM_ED_WriteGlobals (prvm_prog_t *prog, qfile_t *f)
{
- ddef_t *def;
+ mdef_t *def;
int i;
const char *name;
int type;
prog->statestring = va(vabuf, sizeof(vabuf), "PRVM_ED_WriteGlobals, name=%s", name);
FS_Printf(f,"\"%s\" ", name);
- FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)type, (prvm_eval_t *)&prog->globals.generic[def->ofs], valuebuf, sizeof(valuebuf)));
+ FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)type, (prvm_eval_t *)&prog->globals.fp[def->ofs], valuebuf, sizeof(valuebuf)));
prog->statestring = NULL;
}
FS_Print(f,"}\n");
void PRVM_ED_ParseGlobals (prvm_prog_t *prog, const char *data)
{
char keyname[MAX_INPUTLINE];
- ddef_t *key;
+ mdef_t *key;
while (1)
{
returns false if error
=============
*/
-qboolean PRVM_ED_ParseEpair(prvm_prog_t *prog, prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash)
+qbool PRVM_ED_ParseEpair(prvm_prog_t *prog, prvm_edict_t *ent, mdef_t *key, const char *s, qbool parsebackslash)
{
int i, l;
char *new_p;
- ddef_t *def;
+ mdef_t *def;
prvm_eval_t *val;
mfunction_t *func;
if (ent)
- val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
+ val = (prvm_eval_t *)(ent->fields.fp + key->ofs);
else
- val = (prvm_eval_t *)(prog->globals.generic + key->ofs);
+ val = (prvm_eval_t *)(prog->globals.fp + key->ofs);
switch (key->type & ~DEF_SAVEGLOBAL)
{
case ev_string:
PRVM_MEM_IncreaseEdicts(prog);
// if IncreaseEdicts was called the base pointer needs to be updated
if (ent)
- val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
+ val = (prvm_eval_t *)(ent->fields.fp + key->ofs);
val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i));
break;
QC, mg in menu QC.
=============
*/
-static void PRVM_GameCommand(const char *whichprogs, const char *whichcmd)
+static void PRVM_GameCommand(cmd_state_t *cmd, const char *whichprogs, const char *whichcmd)
{
prvm_prog_t *prog;
- if(Cmd_Argc() < 1)
+ if(Cmd_Argc(cmd) < 1)
{
Con_Printf("%s text...\n", whichcmd);
return;
int restorevm_tempstringsbuf_cursize;
const char *s;
- s = Cmd_Args();
+ s = Cmd_Args(cmd);
restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, s ? s : "");
prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
}
-static void PRVM_GameCommand_Server_f(void)
+static void PRVM_GameCommand_Server_f(cmd_state_t *cmd)
{
- PRVM_GameCommand("server", "sv_cmd");
+ PRVM_GameCommand(cmd, "server", "sv_cmd");
}
-static void PRVM_GameCommand_Client_f(void)
+static void PRVM_GameCommand_Client_f(cmd_state_t *cmd)
{
- PRVM_GameCommand("client", "cl_cmd");
+ PRVM_GameCommand(cmd, "client", "cl_cmd");
}
-static void PRVM_GameCommand_Menu_f(void)
+static void PRVM_GameCommand_Menu_f(cmd_state_t *cmd)
{
- PRVM_GameCommand("menu", "menu_cmd");
+ PRVM_GameCommand(cmd, "menu", "menu_cmd");
}
/*
Console command to load a field of a specified edict
=============
*/
-static void PRVM_ED_EdictGet_f(void)
+static void PRVM_ED_EdictGet_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
prvm_edict_t *ed;
- ddef_t *key;
+ mdef_t *key;
const char *s;
prvm_eval_t *v;
char valuebuf[MAX_INPUTLINE];
- if(Cmd_Argc() != 4 && Cmd_Argc() != 5)
+ if(Cmd_Argc(cmd) != 4 && Cmd_Argc(cmd) != 5)
{
Con_Print("prvm_edictget <program name> <edict number> <field> [<cvar>]\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
+ ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(cmd, 2)));
- if((key = PRVM_ED_FindField(prog, Cmd_Argv(3))) == 0)
+ if((key = PRVM_ED_FindField(prog, Cmd_Argv(cmd, 3))) == 0)
{
- Con_Printf("Key %s not found !\n", Cmd_Argv(3));
+ Con_Printf("Key %s not found !\n", Cmd_Argv(cmd, 3));
goto fail;
}
- v = (prvm_eval_t *)(ed->fields.vp + key->ofs);
+ v = (prvm_eval_t *)(ed->fields.fp + key->ofs);
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
- if(Cmd_Argc() == 5)
+ if(Cmd_Argc(cmd) == 5)
{
- cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4));
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("prvm_edictget: %s is read-only\n", cvar->name);
- goto fail;
- }
- Cvar_Get(Cmd_Argv(4), s, 0, NULL);
+ cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 4), cmd->cvars_flagsmask);
+ if (cvar)
+ if(Cvar_Readonly(cvar, "prvm_edictget"))
+ goto fail;
+
+ Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 4), s, cmd->cvars_flagsmask, NULL);
}
else
Con_Printf("%s\n", s);
;
}
-static void PRVM_ED_GlobalGet_f(void)
+static void PRVM_ED_GlobalGet_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
- ddef_t *key;
+ mdef_t *key;
const char *s;
prvm_eval_t *v;
char valuebuf[MAX_INPUTLINE];
- if(Cmd_Argc() != 3 && Cmd_Argc() != 4)
+ if(Cmd_Argc(cmd) != 3 && Cmd_Argc(cmd) != 4)
{
Con_Print("prvm_globalget <program name> <global> [<cvar>]\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- key = PRVM_ED_FindGlobal(prog, Cmd_Argv(2));
+ key = PRVM_ED_FindGlobal(prog, Cmd_Argv(cmd, 2));
if(!key)
{
- Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+ Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
goto fail;
}
- v = (prvm_eval_t *) &prog->globals.generic[key->ofs];
+ v = (prvm_eval_t *) &prog->globals.fp[key->ofs];
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
- if(Cmd_Argc() == 4)
+ if(Cmd_Argc(cmd) == 4)
{
- cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3));
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("prvm_globalget: %s is read-only\n", cvar->name);
- goto fail;
- }
- Cvar_Get(Cmd_Argv(3), s, 0, NULL);
+ cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 3), cmd->cvars_flagsmask);
+ if (cvar)
+ if(Cvar_Readonly(cvar, "prvm_globalget"))
+ goto fail;
+ Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 3), s, cmd->cvars_flagsmask, NULL);
}
else
Con_Printf("%s\n", s);
Console command to set a field of a specified edict
=============
*/
-static void PRVM_ED_EdictSet_f(void)
+static void PRVM_ED_EdictSet_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
prvm_edict_t *ed;
- ddef_t *key;
+ mdef_t *key;
- if(Cmd_Argc() != 5)
+ if(Cmd_Argc(cmd) != 5)
{
Con_Print("prvm_edictset <program name> <edict number> <field> <value>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
+ ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(cmd, 2)));
- if((key = PRVM_ED_FindField(prog, Cmd_Argv(3))) == 0)
- Con_Printf("Key %s not found !\n", Cmd_Argv(3));
+ if((key = PRVM_ED_FindField(prog, Cmd_Argv(cmd, 3))) == 0)
+ Con_Printf("Key %s not found!\n", Cmd_Argv(cmd, 3));
else
- PRVM_ED_ParseEpair(prog, ed, key, Cmd_Argv(4), true);
+ PRVM_ED_ParseEpair(prog, ed, key, Cmd_Argv(cmd, 4), true);
}
/*
*/
const char *PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_t *ent)
{
- ddef_t *key;
- qboolean anglehack;
- qboolean init;
+ mdef_t *key;
+ qbool anglehack;
+ qbool init;
char keyname[256];
size_t n;
prog->error_cmd("PRVM_ED_ParseEdict: parse error");
}
- if (!init)
- ent->priv.required->free = true;
+ if (!init) {
+ ent->free = true;
+ ent->freetime = host.realtime;
+ }
return data;
}
+void PRVM_ED_CallPrespawnFunction(prvm_prog_t *prog, prvm_edict_t *ent)
+{
+ if (PRVM_serverfunction(SV_OnEntityPreSpawnFunction))
+ {
+ // self = ent
+ PRVM_serverglobalfloat(time) = sv.time;
+ PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+ prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPreSpawnFunction), "QC function SV_OnEntityPreSpawnFunction is missing");
+ }
+}
+
+qbool PRVM_ED_CallSpawnFunction(prvm_prog_t *prog, prvm_edict_t *ent, const char *data, const char *start)
+{
+ const char *funcname;
+ mfunction_t *func;
+ prvm_eval_t *fulldata = NULL;
+ char vabuf[1024];
+
+//
+// immediately call spawn function, but only if there is a self global and a classname
+//
+ if (!ent->free)
+ {
+ if (!PRVM_alledictstring(ent, classname))
+ {
+ Con_Print("No classname for:\n");
+ PRVM_ED_Print(prog, ent, NULL);
+ PRVM_ED_Free (prog, ent);
+ return false;
+ }
+ /*
+ * This is required for FTE compatibility (FreeCS).
+ * It copies the key/value pairs themselves into a
+ * global for QC to parse on its own.
+ */
+ else if (data && start)
+ {
+ if((fulldata = PRVM_ED_FindGlobalEval(prog, "__fullspawndata")))
+ {
+ const char *in;
+ char *spawndata;
+ fulldata->string = PRVM_AllocString(prog, data - start + 1, &spawndata);
+ for(in = start; in < data; )
+ {
+ char c = *in++;
+ if(c == '\n')
+ *spawndata++ = '\t';
+ else
+ *spawndata++ = c;
+ }
+ *spawndata = 0;
+ }
+ }
+
+ // look for the spawn function
+ funcname = PRVM_GetString(prog, PRVM_alledictstring(ent, classname));
+ func = PRVM_ED_FindFunction (prog, va(vabuf, sizeof(vabuf), "spawnfunc_%s", funcname));
+ if(!func)
+ if(!PRVM_allglobalfloat(require_spawnfunc_prefix))
+ func = PRVM_ED_FindFunction (prog, funcname);
+
+ if (!func)
+ {
+ // check for OnEntityNoSpawnFunction
+ if (PRVM_serverfunction(SV_OnEntityNoSpawnFunction))
+ {
+ // self = ent
+ PRVM_serverglobalfloat(time) = sv.time;
+ PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+ prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityNoSpawnFunction), "QC function SV_OnEntityNoSpawnFunction is missing");
+ }
+ else
+ {
+
+ Con_DPrint("No spawn function for:\n");
+ if (developer.integer > 0) // don't confuse non-developers with errors
+ PRVM_ED_Print(prog, ent, NULL);
+
+ PRVM_ED_Free (prog, ent);
+ return false; // not included in "inhibited" count
+ }
+ }
+ else
+ {
+ // self = ent
+ PRVM_serverglobalfloat(time) = sv.time;
+ PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+ prog->ExecuteProgram(prog, func - prog->functions, "");
+ }
+ return true;
+ }
+ PRVM_ED_Free(prog, ent);
+ return false;
+}
+
+void PRVM_ED_CallPostspawnFunction (prvm_prog_t *prog, prvm_edict_t *ent)
+{
+ if(!ent->free)
+ if (PRVM_serverfunction(SV_OnEntityPostSpawnFunction))
+ {
+ // self = ent
+ PRVM_serverglobalfloat(time) = sv.time;
+ PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+ prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPostSpawnFunction), "QC function SV_OnEntityPostSpawnFunction is missing");
+ }
+}
/*
================
void PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data)
{
prvm_edict_t *ent;
+ const char *start;
int parsed, inhibited, spawned, died;
- const char *funcname;
- mfunction_t *func;
- char vabuf[1024];
parsed = 0;
inhibited = 0;
spawned = 0;
died = 0;
- prvm_reuseedicts_always_allow = realtime;
+ prvm_reuseedicts_always_allow = host.realtime;
-// parse ents
+ // parse ents
while (1)
{
-// parse the opening brace
+ start = data;
+
+ // parse the opening brace
if (!COM_ParseToken_Simple(&data, false, false, true))
break;
if (com_token[0] != '{')
// clear it
if (ent != prog->edicts) // hack
- memset (ent->fields.vp, 0, prog->entityfields * 4);
+ memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
data = PRVM_ED_ParseEdict (prog, data, ent);
parsed++;
continue;
}
- if (PRVM_serverfunction(SV_OnEntityPreSpawnFunction))
- {
- // self = ent
- PRVM_serverglobalfloat(time) = sv.time;
- PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
- prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPreSpawnFunction), "QC function SV_OnEntityPreSpawnFunction is missing");
- }
+ PRVM_ED_CallPrespawnFunction(prog, ent);
- if(ent->priv.required->free)
+ if(ent->free)
{
inhibited++;
continue;
}
-//
-// immediately call spawn function, but only if there is a self global and a classname
-//
- if(!ent->priv.required->free)
- {
- if (!PRVM_alledictstring(ent, classname))
- {
- Con_Print("No classname for:\n");
- PRVM_ED_Print(prog, ent, NULL);
- PRVM_ED_Free (prog, ent);
- continue;
- }
-
- // look for the spawn function
- funcname = PRVM_GetString(prog, PRVM_alledictstring(ent, classname));
- func = PRVM_ED_FindFunction (prog, va(vabuf, sizeof(vabuf), "spawnfunc_%s", funcname));
- if(!func)
- if(!PRVM_allglobalfloat(require_spawnfunc_prefix))
- func = PRVM_ED_FindFunction (prog, funcname);
+ SV_LinkEdict(ent);
- if (!func)
- {
- // check for OnEntityNoSpawnFunction
- if (PRVM_serverfunction(SV_OnEntityNoSpawnFunction))
- {
- // self = ent
- PRVM_serverglobalfloat(time) = sv.time;
- PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
- prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityNoSpawnFunction), "QC function SV_OnEntityNoSpawnFunction is missing");
- }
- else
- {
- if (developer.integer > 0) // don't confuse non-developers with errors
- {
- Con_Print("No spawn function for:\n");
- PRVM_ED_Print(prog, ent, NULL);
- }
- PRVM_ED_Free (prog, ent);
- continue; // not included in "inhibited" count
- }
- }
- else
- {
- // self = ent
- PRVM_serverglobalfloat(time) = sv.time;
- PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
- prog->ExecuteProgram(prog, func - prog->functions, "");
- }
- }
-
- if(!ent->priv.required->free)
- if (PRVM_serverfunction(SV_OnEntityPostSpawnFunction))
- {
- // self = ent
- PRVM_serverglobalfloat(time) = sv.time;
- PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
- prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPostSpawnFunction), "QC function SV_OnEntityPostSpawnFunction is missing");
- }
+ if(!PRVM_ED_CallSpawnFunction(prog, ent, data, start))
+ continue;
+
+ PRVM_ED_CallPostspawnFunction(prog, ent);
spawned++;
- if (ent->priv.required->free)
+ if (ent->free)
died++;
}
case '\\': if(outsize > 0) { *out++ = '\\'; --outsize; } break;
case '"': if(outsize > 0) { *out++ = '"'; --outsize; } break;
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
- if(outsize > 0)
+ if(outsize > 0)
*out = *in - '0';
++in;
if(*in >= '0' && *in <= '7')
++in;
}
}
-static po_t *PRVM_PO_Load(const char *filename, mempool_t *pool)
+static po_t *PRVM_PO_Load(const char *filename, const char *filename2, mempool_t *pool)
{
- po_t *po;
+ po_t *po = NULL;
const char *p, *q;
int mode;
char inbuf[MAX_INPUTLINE];
size_t decodedpos;
int hashindex;
po_string_t thisstr;
- const char *buf = (const char *) FS_LoadFile(filename, pool, true, NULL);
-
- if(!buf)
- return NULL;
-
- memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning
-
- po = (po_t *)Mem_Alloc(pool, sizeof(*po));
- memset(po, 0, sizeof(*po));
+ int i;
- p = buf;
- while(*p)
+ for (i = 0; i < 2; ++i)
{
- if(*p == '#')
- {
- // skip to newline
- p = strchr(p, '\n');
- if(!p)
- break;
- ++p;
- continue;
- }
- if(*p == '\r' || *p == '\n')
- {
- ++p;
+ const char *buf = (const char *)
+ FS_LoadFile((i > 0 ? filename : filename2), pool, true, NULL);
+ // first read filename2, then read filename
+ // so that progs.dat.de.po wins over common.de.po
+ // and within file, last item wins
+
+ if(!buf)
continue;
- }
- if(!strncmp(p, "msgid \"", 7))
- {
- mode = 0;
- p += 6;
- }
- else if(!strncmp(p, "msgstr \"", 8))
+
+ if (!po)
{
- mode = 1;
- p += 7;
+ po = (po_t *)Mem_Alloc(pool, sizeof(*po));
+ memset(po, 0, sizeof(*po));
}
- else
+
+ memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning
+
+ p = buf;
+ while(*p)
{
- p = strchr(p, '\n');
- if(!p)
- break;
- ++p;
- continue;
+ if(*p == '#')
+ {
+ // skip to newline
+ p = strchr(p, '\n');
+ if(!p)
+ break;
+ ++p;
+ continue;
+ }
+ if(*p == '\r' || *p == '\n')
+ {
+ ++p;
+ continue;
+ }
+ if(!strncmp(p, "msgid \"", 7))
+ {
+ mode = 0;
+ p += 6;
+ }
+ else if(!strncmp(p, "msgstr \"", 8))
+ {
+ mode = 1;
+ p += 7;
+ }
+ else
+ {
+ p = strchr(p, '\n');
+ if(!p)
+ break;
+ ++p;
+ continue;
+ }
+ decodedpos = 0;
+ while(*p == '"')
+ {
+ ++p;
+ q = strchr(p, '\n');
+ if(!q)
+ break;
+ if(*(q-1) == '\r')
+ --q;
+ if(*(q-1) != '"')
+ break;
+ if((size_t)(q - p) >= (size_t) sizeof(inbuf))
+ break;
+ strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL
+ PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos);
+ decodedpos += strlen(decodedbuf + decodedpos);
+ if(*q == '\r')
+ ++q;
+ if(*q == '\n')
+ ++q;
+ p = q;
+ }
+ if(mode == 0)
+ {
+ if(thisstr.key)
+ Mem_Free(thisstr.key);
+ thisstr.key = (char *)Mem_Alloc(pool, decodedpos + 1);
+ memcpy(thisstr.key, decodedbuf, decodedpos + 1);
+ }
+ else if(decodedpos > 0 && thisstr.key) // skip empty translation results
+ {
+ thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1);
+ memcpy(thisstr.value, decodedbuf, decodedpos + 1);
+ hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
+ thisstr.nextonhashchain = po->hashtable[hashindex];
+ po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr));
+ memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
+ memset(&thisstr, 0, sizeof(thisstr));
+ }
}
- decodedpos = 0;
- while(*p == '"')
- {
- ++p;
- q = strchr(p, '\n');
- if(!q)
- break;
- if(*(q-1) == '\r')
- --q;
- if(*(q-1) != '"')
- break;
- if((size_t)(q - p) >= (size_t) sizeof(inbuf))
- break;
- strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL
- PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos);
- decodedpos += strlen(decodedbuf + decodedpos);
- if(*q == '\r')
- ++q;
- if(*q == '\n')
- ++q;
- p = q;
- }
- if(mode == 0)
- {
- if(thisstr.key)
- Mem_Free(thisstr.key);
- thisstr.key = (char *)Mem_Alloc(pool, decodedpos + 1);
- memcpy(thisstr.key, decodedbuf, decodedpos + 1);
- }
- else if(decodedpos > 0 && thisstr.key) // skip empty translation results
- {
- thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1);
- memcpy(thisstr.value, decodedbuf, decodedpos + 1);
- hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
- thisstr.nextonhashchain = po->hashtable[hashindex];
- po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr));
- memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
- memset(&thisstr, 0, sizeof(thisstr));
- }
- }
-
- Mem_Free((char *) buf);
+
+ Mem_Free((char *) buf);
+ }
+
return po;
}
static const char *PRVM_PO_Lookup(po_t *po, const char *str)
void PRVM_LeakTest(prvm_prog_t *prog);
void PRVM_Prog_Reset(prvm_prog_t *prog)
{
- PRVM_LeakTest(prog);
- prog->reset_cmd(prog);
- Mem_FreePool(&prog->progs_mempool);
- if(prog->po)
- PRVM_PO_Destroy((po_t *) prog->po);
+ if (prog->loaded)
+ {
+ if(prog->tempstringsbuf.cursize)
+ Mem_Free(prog->tempstringsbuf.data);
+ prog->tempstringsbuf.cursize = 0;
+ PRVM_LeakTest(prog);
+ prog->reset_cmd(prog);
+ Mem_FreePool(&prog->progs_mempool);
+ if(prog->po)
+ PRVM_PO_Destroy((po_t *) prog->po);
+ }
memset(prog,0,sizeof(prvm_prog_t));
+ prog->break_statement = -1;
+ prog->watch_global_type = ev_void;
+ prog->watch_field_type = ev_void;
}
/*
(unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs_numstatements )
{
prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof( int ) );
- memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs_numstatements * sizeof( int ) );
+ memcpy( prog->statement_linenums, header + 6, prog->progs_numstatements * sizeof( int ) );
+
+ /* gmqcc suports columnums */
+ if ((unsigned int)filesize > ((6 + 2 * prog->progs_numstatements) * sizeof( int )))
+ {
+ prog->statement_columnnums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof( int ) );
+ memcpy( prog->statement_columnnums, header + 6 + prog->progs_numstatements, prog->progs_numstatements * sizeof( int ) );
+ }
}
Mem_Free( lno );
}
PRVM_LoadProgs
===============
*/
-void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, int numrequiredfunc, const char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, prvm_required_field_t *required_global)
+static void PRVM_UpdateBreakpoints(prvm_prog_t *prog);
+void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * data, fs_offset_t size, int numrequiredfunc, const char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, prvm_required_field_t *required_global)
{
int i;
dprograms_t *dprograms;
- dstatement_t *instatements;
- ddef_t *infielddefs;
- ddef_t *inglobaldefs;
- float *inglobals;
+
+ dstatement16_t *instatements16;
+ dstatement32_t *instatements32;
+ ddef16_t *infielddefs16;
+ ddef32_t *infielddefs32;
+ ddef16_t *inglobaldefs16;
+ ddef32_t *inglobaldefs32;
+
+ int *inglobals;
dfunction_t *infunctions;
char *instrings;
fs_offset_t filesize;
int a;
int b;
int c;
+ union
+ {
+ unsigned int i;
+ float f;
+ }
+ u;
+ unsigned int d;
char vabuf[1024];
+ char vabuf2[1024];
+ cvar_t *cvar;
+ int structtype = 0;
if (prog->loaded)
prog->error_cmd("PRVM_LoadProgs: there is already a %s program loaded!", prog->name );
Host_LockSession(); // all progs can use the session cvar
Crypto_LoadKeys(); // all progs might use the keys at init time
- dprograms = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
+ if (data)
+ {
+ dprograms = (dprograms_t *) data;
+ filesize = size;
+ }
+ else
+ dprograms = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
if (dprograms == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
prog->error_cmd("PRVM_LoadProgs: couldn't load %s for %s", filename, prog->name);
// TODO bounds check header fields (e.g. numstatements), they must never go behind end of file
prog->profiletime = Sys_DirtyTime();
- prog->starttime = realtime;
-
- Con_DPrintf("%s programs occupy %iK.\n", prog->name, (int)(filesize/1024));
+ prog->starttime = host.realtime;
requiredglobalspace = 0;
for (i = 0;i < numrequiredglobals;i++)
// byte swap the header
prog->progs_version = LittleLong(dprograms->version);
prog->progs_crc = LittleLong(dprograms->crc);
- if (prog->progs_version != PROG_VERSION)
+ if (prog->progs_version == 7)
+ {
+ dprograms_v7_t *v7 = (dprograms_v7_t*)dprograms;
+ structtype = LittleLong(v7->secondaryversion);
+ if (structtype == PROG_SECONDARYVERSION16 ||
+ structtype == PROG_SECONDARYVERSION32) // barely supported
+ Con_Printf(CON_WARN "WARNING: %s: %s targets FTEQW, for which support is incomplete. Proceed at your own risk.\n", prog->name, filename);
+ else
+ prog->error_cmd("%s: %s targets unknown engine", prog->name, filename);
+
+ if (v7->numbodylessfuncs != 0 || v7->numtypes != 0 || v7->blockscompressed != 0)
+ prog->error_cmd("%s: %s uses unsupported features.", prog->name, filename);
+ }
+ else if (prog->progs_version != PROG_VERSION)
prog->error_cmd("%s: %s has wrong version number (%i should be %i)", prog->name, filename, prog->progs_version, PROG_VERSION);
- instatements = (dstatement_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_statements));
+ instatements16 = (dstatement16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_statements));
+ instatements32 = (dstatement32_t *)instatements16;
prog->progs_numstatements = LittleLong(dprograms->numstatements);
- inglobaldefs = (ddef_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globaldefs));
+ inglobaldefs16 = (ddef16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globaldefs));
+ inglobaldefs32 = (ddef32_t *)inglobaldefs16;
prog->progs_numglobaldefs = LittleLong(dprograms->numglobaldefs);
- infielddefs = (ddef_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_fielddefs));
+ infielddefs16 = (ddef16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_fielddefs));
+ infielddefs32 = (ddef32_t *)infielddefs16;
prog->progs_numfielddefs = LittleLong(dprograms->numfielddefs);
infunctions = (dfunction_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_functions));
prog->progs_numfunctions = LittleLong(dprograms->numfunctions);
instrings = (char *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_strings));
prog->progs_numstrings = LittleLong(dprograms->numstrings);
- inglobals = (float *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globals));
+ inglobals = (int *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globals));
prog->progs_numglobals = LittleLong(dprograms->numglobals);
prog->progs_entityfields = LittleLong(dprograms->entityfields);
prog->numglobals = prog->progs_numglobals;
prog->entityfields = prog->progs_entityfields;
- if (LittleLong(dprograms->ofs_strings) + prog->progs_numstrings >= (int)filesize)
+ if (LittleLong(dprograms->ofs_strings) + prog->progs_numstrings > (int)filesize)
prog->error_cmd("%s: %s strings go past end of file", prog->name, filename);
prog->strings = (char *)Mem_Alloc(prog->progs_mempool, prog->progs_numstrings);
memcpy(prog->strings, instrings, prog->progs_numstrings);
prog->numknownstrings = 0;
prog->maxknownstrings = 0;
prog->knownstrings = NULL;
- prog->knownstrings_freeable = NULL;
+ prog->knownstrings_flags = NULL;
Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64);
// we need to expand the globaldefs and fielddefs to include engine defs
- prog->globaldefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobaldefs + numrequiredglobals) * sizeof(ddef_t));
- prog->globals.generic = (float *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobals + requiredglobalspace) * sizeof(float));
- prog->fielddefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numfielddefs + numrequiredfields) * sizeof(ddef_t));
+ prog->globaldefs = (mdef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobaldefs + numrequiredglobals) * sizeof(mdef_t));
+ prog->globals.fp = (prvm_vec_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobals + requiredglobalspace + 2) * sizeof(prvm_vec_t));
+ // + 2 is because of an otherwise occurring overrun in RETURN instruction
+ // when trying to return the last or second-last global
+ // (RETURN always returns a vector, there is no RETURN_F instruction)
+ prog->fielddefs = (mdef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numfielddefs + numrequiredfields) * sizeof(mdef_t));
// we need to convert the statements to our memory format
prog->statements = (mstatement_t *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(mstatement_t));
// allocate space for profiling statement usage
prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(*prog->statement_profile));
+ prog->explicit_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(*prog->statement_profile));
// functions need to be converted to the memory format
prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs_numfunctions);
}
// copy the globaldefs to the new globaldefs list
- for (i=0 ; i<prog->numglobaldefs ; i++)
+ switch(structtype)
{
- prog->globaldefs[i].type = LittleShort(inglobaldefs[i].type);
- prog->globaldefs[i].ofs = LittleShort(inglobaldefs[i].ofs);
- prog->globaldefs[i].s_name = LittleLong(inglobaldefs[i].s_name);
- // TODO bounds check ofs, s_name
+ case PROG_SECONDARYVERSION32:
+ for (i=0 ; i<prog->numglobaldefs ; i++)
+ {
+ prog->globaldefs[i].type = LittleLong(inglobaldefs32[i].type);
+ prog->globaldefs[i].ofs = LittleLong(inglobaldefs32[i].ofs);
+ prog->globaldefs[i].s_name = LittleLong(inglobaldefs32[i].s_name);
+ // TODO bounds check ofs, s_name
+ }
+ break;
+ default:
+ for (i=0 ; i<prog->numglobaldefs ; i++)
+ {
+ prog->globaldefs[i].type = (unsigned short)LittleShort(inglobaldefs16[i].type);
+ prog->globaldefs[i].ofs = (unsigned short)LittleShort(inglobaldefs16[i].ofs);
+ prog->globaldefs[i].s_name = LittleLong(inglobaldefs16[i].s_name);
+ // TODO bounds check ofs, s_name
+ }
+ break;
}
// append the required globals
}
// copy the progs fields to the new fields list
- for (i = 0;i < prog->numfielddefs;i++)
+ switch(structtype)
{
- prog->fielddefs[i].type = LittleShort(infielddefs[i].type);
- if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
- prog->error_cmd("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", prog->name);
- prog->fielddefs[i].ofs = LittleShort(infielddefs[i].ofs);
- prog->fielddefs[i].s_name = LittleLong(infielddefs[i].s_name);
- // TODO bounds check ofs, s_name
+ case PROG_SECONDARYVERSION32:
+ for (i = 0;i < prog->numfielddefs;i++)
+ {
+ prog->fielddefs[i].type = LittleLong(infielddefs32[i].type);
+ if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
+ prog->error_cmd("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", prog->name);
+ prog->fielddefs[i].ofs = LittleLong(infielddefs32[i].ofs);
+ prog->fielddefs[i].s_name = LittleLong(infielddefs32[i].s_name);
+ // TODO bounds check ofs, s_name
+ }
+ break;
+ default:
+ for (i = 0;i < prog->numfielddefs;i++)
+ {
+ prog->fielddefs[i].type = (unsigned short)LittleShort(infielddefs16[i].type);
+ if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
+ prog->error_cmd("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", prog->name);
+ prog->fielddefs[i].ofs = (unsigned short)LittleShort(infielddefs16[i].ofs);
+ prog->fielddefs[i].s_name = LittleLong(infielddefs16[i].s_name);
+ // TODO bounds check ofs, s_name
+ }
+ break;
}
// append the required fields
prog->numfielddefs++;
}
- // LordHavoc: TODO: reorder globals to match engine struct
- // LordHavoc: TODO: reorder fields to match engine struct
+ // LadyHavoc: TODO: reorder globals to match engine struct
+ // LadyHavoc: TODO: reorder fields to match engine struct
#define remapglobal(index) (index)
#define remapfield(index) (index)
// copy globals
+ // FIXME: LadyHavoc: this uses a crude way to identify integer constants, rather than checking for matching globaldefs and checking their type
for (i = 0;i < prog->progs_numglobals;i++)
- ((int *)prog->globals.generic)[remapglobal(i)] = LittleLong(((int *)inglobals)[i]);
+ {
+ u.i = LittleLong(inglobals[i]);
+ // most globals are 0, we only need to deal with the ones that are not
+ if (u.i)
+ {
+ d = u.i & 0xFF800000;
+ if ((d == 0xFF800000) || (d == 0))
+ {
+ // Looks like an integer (expand to int64)
+ prog->globals.ip[remapglobal(i)] = u.i;
+ }
+ else
+ {
+ // Looks like a float (expand to double)
+ prog->globals.fp[remapglobal(i)] = u.f;
+ }
+ }
+ }
- // LordHavoc: TODO: support 32bit progs statement formats
// copy, remap globals in statements, bounds check
for (i = 0;i < prog->progs_numstatements;i++)
{
- op = (opcode_t)LittleShort(instatements[i].op);
- a = (unsigned short)LittleShort(instatements[i].a);
- b = (unsigned short)LittleShort(instatements[i].b);
- c = (unsigned short)LittleShort(instatements[i].c);
+ switch(structtype)
+ {
+ case PROG_SECONDARYVERSION32:
+ op = (opcode_t)LittleLong(instatements32[i].op);
+ a = (unsigned int)LittleLong(instatements32[i].a);
+ b = (unsigned int)LittleLong(instatements32[i].b);
+ c = (unsigned int)LittleLong(instatements32[i].c);
+ break;
+ default:
+ op = (opcode_t)LittleShort(instatements16[i].op);
+ a = (unsigned short)LittleShort(instatements16[i].a);
+ b = (unsigned short)LittleShort(instatements16[i].b);
+ c = (unsigned short)LittleShort(instatements16[i].c);
+ break;
+ }
switch (op)
{
case OP_IF:
break;
default:
Con_DPrintf("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", (int)op, i, prog->name);
+
+ //make sure its something well defined.
+ prog->statements[i].op = OP_BOUNDCHECK;
+ prog->statements[i].operand[0] = 0;
+ prog->statements[i].operand[1] =
+ prog->statements[i].operand[2] = op;
+ prog->statements[i].jumpabsolute = -1;
+ break;
+ case OP_STORE_I:
+ case OP_ADD_I:
+ case OP_ADD_FI:
+ case OP_ADD_IF:
+ case OP_SUB_I:
+ case OP_SUB_FI:
+ case OP_SUB_IF:
+ case OP_CONV_IF:
+ case OP_CONV_FI:
+ case OP_LOAD_I:
+ case OP_STOREP_I:
+ case OP_BITAND_I:
+ case OP_BITOR_I:
+ case OP_MUL_I:
+ case OP_DIV_I:
+ case OP_EQ_I:
+ case OP_NE_I:
+ case OP_NOT_I:
+ case OP_DIV_VF:
+ case OP_STORE_P:
+ case OP_LE_I:
+ case OP_GE_I:
+ case OP_LT_I:
+ case OP_GT_I:
+ case OP_LE_IF:
+ case OP_GE_IF:
+ case OP_LT_IF:
+ case OP_GT_IF:
+ case OP_LE_FI:
+ case OP_GE_FI:
+ case OP_LT_FI:
+ case OP_GT_FI:
+ case OP_EQ_IF:
+ case OP_EQ_FI:
+ case OP_MUL_IF:
+ case OP_MUL_FI:
+ case OP_MUL_VI:
+ case OP_DIV_IF:
+ case OP_DIV_FI:
+ case OP_BITAND_IF:
+ case OP_BITOR_IF:
+ case OP_BITAND_FI:
+ case OP_BITOR_FI:
+ case OP_AND_I:
+ case OP_OR_I:
+ case OP_AND_IF:
+ case OP_OR_IF:
+ case OP_AND_FI:
+ case OP_OR_FI:
+ case OP_NE_IF:
+ case OP_NE_FI:
+ case OP_GSTOREP_I:
+ case OP_GSTOREP_F:
+ case OP_GSTOREP_ENT:
+ case OP_GSTOREP_FLD:
+ case OP_GSTOREP_S:
+ case OP_GSTOREP_FNC:
+ case OP_GSTOREP_V:
+// case OP_GADDRESS:
+ case OP_GLOAD_I:
+ case OP_GLOAD_F:
+ case OP_GLOAD_FLD:
+ case OP_GLOAD_ENT:
+ case OP_GLOAD_S:
+ case OP_GLOAD_FNC:
+ case OP_BOUNDCHECK:
+ case OP_GLOAD_V:
+
// global global global
case OP_ADD_F:
case OP_ADD_V:
case OP_STOREP_FLD:
case OP_STOREP_S:
case OP_STOREP_FNC:
+ if (c) //Spike -- DP is alergic to pointers in QC. Try to avoid too many nasty surprises.
+ Con_DPrintf("PRVM_LoadProgs: storep-with-offset is not permitted in %s\n", prog->name);
+ //fallthrough
case OP_STORE_F:
case OP_STORE_ENT:
case OP_STORE_FLD:
break;
// 1 global
case OP_CALL0:
+ if ( a < prog->progs_numglobals)
+ if ( prog->globals.ip[remapglobal(a)] >= 0 )
+ if ( prog->globals.ip[remapglobal(a)] < prog->progs_numfunctions )
+ if ( prog->functions[prog->globals.ip[remapglobal(a)]].first_statement == -642 )
+ ++prog->numexplicitcoveragestatements;
case OP_CALL1:
case OP_CALL2:
case OP_CALL3:
case OP_RETURN:
if ( a >= prog->progs_numglobals)
prog->error_cmd("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, prog->name);
+ if (b || c) //Spike -- added this check just as a diagnostic...
+ Con_DPrintf("PRVM_LoadProgs: unexpected offset on call opcode in %s. Hexen2 format is not supported\n", prog->name);
prog->statements[i].op = op;
prog->statements[i].operand[0] = remapglobal(a);
prog->statements[i].operand[1] = -1;
}
// we're done with the file now
- Mem_Free(dprograms);
+ if(!data)
+ Mem_Free(dprograms);
dprograms = NULL;
// check required functions
// in CSQC we really shouldn't be able to change how stuff works... sorry for now
// later idea: include a list of authorized .po file checksums with the csprogs
{
- qboolean deftrans = prog == CLVM_prog;
+ qbool deftrans = prog == CLVM_prog;
const char *realfilename = (prog != CLVM_prog ? filename : csqc_progname.string);
if(deftrans) // once we have dotranslate_ strings, ALWAYS use the opt-in method!
{
}
else
{
- po_t *po = PRVM_PO_Load(va(vabuf, sizeof(vabuf), "%s.%s.po", realfilename, prvm_language.string), prog->progs_mempool);
+ po_t *po = PRVM_PO_Load(
+ va(vabuf, sizeof(vabuf), "%s.%s.po", realfilename, prvm_language.string),
+ va(vabuf2, sizeof(vabuf2), "common.%s.po", prvm_language.string),
+ prog->progs_mempool);
if(po)
{
for (i=0 ; i<prog->numglobaldefs ; i++)
}
}
+ for (cvar = prog->console_cmd->cvars->vars; cvar; cvar = cvar->next)
+ cvar->globaldefindex[prog - prvm_prog_list] = -1;
+
for (i=0 ; i<prog->numglobaldefs ; i++)
{
const char *name;
)
{
prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
- cvar_t *cvar = Cvar_FindVar(name + 9);
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, name + 9, prog->console_cmd->cvars_flagsmask);
//Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, prog->name);
if(!cvar)
{
const char *value;
- char buf[64];
+ char buf[128];
+ int prec[3];
+ float f;
Con_DPrintf("PRVM_LoadProgs: no cvar for autocvar global %s in %s, creating...\n", name, prog->name);
switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
{
if((float)((int)(val->_float)) == val->_float)
dpsnprintf(buf, sizeof(buf), "%i", (int)(val->_float));
else
- dpsnprintf(buf, sizeof(buf), "%.9g", val->_float);
+ {
+ // ftos_slow
+ f = val->_float;
+ for (int precision = 7; precision <= 9; ++precision) {
+ dpsnprintf(buf, sizeof(buf), "%.*g", precision, f);
+ if ((float)atof(buf) == f) {
+ break;
+ }
+ }
+ }
value = buf;
break;
case ev_vector:
- dpsnprintf(buf, sizeof(buf), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]); value = buf;
+ for (i = 0; i < 3; ++i)
+ {
+ prec[i] = 9;
+ f = val->vector[i];
+ for (int precision = 7; precision <= 9; ++precision) {
+ dpsnprintf(buf, sizeof(buf), "%.*g", precision, f);
+ if ((float)atof(buf) == f) {
+ prec[i] = precision;
+ break;
+ }
+ }
+ }
+ dpsnprintf(buf, sizeof(buf), "%.*g %.*g %.*g", prec[0], val->vector[0], prec[1], val->vector[1], prec[2], val->vector[2]);
+ value = buf;
break;
case ev_string:
value = PRVM_GetString(prog, val->string);
Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, prog->name);
goto fail;
}
- cvar = Cvar_Get(name + 9, value, 0, NULL);
+ cvar = Cvar_Get(prog->console_cmd->cvars, name + 9, value, prog->console_cmd->cvars_flagsmask, NULL);
if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
{
val->string = PRVM_SetEngineString(prog, cvar->string);
}
if(!cvar)
prog->error_cmd("PRVM_LoadProgs: could not create cvar for autocvar global %s in %s", name, prog->name);
- cvar->globaldefindex_progid[prog - prvm_prog_list] = prog->id;
cvar->globaldefindex[prog - prvm_prog_list] = i;
}
- else if((cvar->flags & CVAR_PRIVATE) == 0)
+ else if((cvar->flags & CF_PRIVATE) == 0)
{
// MUST BE SYNCED WITH cvar.c Cvar_Set
int j;
Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, prog->name);
goto fail;
}
- cvar->globaldefindex_progid[prog - prvm_prog_list] = prog->id;
cvar->globaldefindex[prog - prvm_prog_list] = i;
}
else
;
}
- prog->loaded = TRUE;
+ prog->loaded = true;
- // set flags & ddef_ts in prog
+ PRVM_UpdateBreakpoints(prog);
+
+ // set flags & mdef_ts in prog
prog->flag = 0;
// init mempools
PRVM_MEM_Alloc(prog);
+
+ Con_Printf("%s: program loaded (crc %i, size %iK)\n", prog->name, prog->filecrc, (int)(filesize/1024));
+
+ // Inittime is at least the time when this function finished. However,
+ // later events may bump it.
+ prog->inittime = host.realtime;
}
-static void PRVM_Fields_f (void)
+static void PRVM_Fields_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
int i, j, ednum, used, usedamount;
char tempstring[MAX_INPUTLINE], tempstring2[260];
const char *name;
prvm_edict_t *ed;
- ddef_t *d;
- int *v;
+ mdef_t *d;
+ prvm_eval_t *val;
// TODO
/*
}
*/
- if(Cmd_Argc() != 2)
+ if(Cmd_Argc(cmd) != 2)
{
Con_Print("prvm_fields <program name>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
counts = (int *)Mem_Alloc(tempmempool, prog->numfielddefs * sizeof(int));
for (ednum = 0;ednum < prog->max_edicts;ednum++)
{
ed = PRVM_EDICT_NUM(ednum);
- if (ed->priv.required->free)
+ if (ed->free)
continue;
for (i = 1;i < prog->numfielddefs;i++)
{
name = PRVM_GetString(prog, d->s_name);
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
- v = (int *)(ed->fields.vp + d->ofs);
+ val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
// if the value is still all 0, skip the field
for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
{
- if (v[j])
+ if (val->ivector[j])
{
counts[i]++;
break;
Con_Printf("%s: %i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", prog->name, prog->entityfields, used, prog->entityfields * 4, usedamount * 4, prog->max_edicts, prog->entityfields * 4 * prog->max_edicts, usedamount * 4 * prog->max_edicts);
}
-static void PRVM_Globals_f (void)
+static void PRVM_Globals_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
int i;
Con_Print("no progs loaded\n");
return;
}*/
- if(Cmd_Argc () < 2 || Cmd_Argc() > 3)
+ if(Cmd_Argc (cmd) < 2 || Cmd_Argc(cmd) > 3)
{
Con_Print("prvm_globals <program name> <optional name wildcard>\n");
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- if( Cmd_Argc() == 3)
- wildcard = Cmd_Argv(2);
+ if( Cmd_Argc(cmd) == 3)
+ wildcard = Cmd_Argv(cmd, 2);
else
wildcard = NULL;
PRVM_Global
===============
*/
-static void PRVM_Global_f(void)
+static void PRVM_Global_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
- ddef_t *global;
+ mdef_t *global;
char valuebuf[MAX_INPUTLINE];
- if( Cmd_Argc() != 3 ) {
+ if( Cmd_Argc(cmd) != 3 ) {
Con_Printf( "prvm_global <program name> <global name>\n" );
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- global = PRVM_ED_FindGlobal( prog, Cmd_Argv(2) );
+ global = PRVM_ED_FindGlobal( prog, Cmd_Argv(cmd, 2) );
if( !global )
- Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+ Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
else
- Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( prog, (etype_t)global->type, PRVM_GLOBALFIELDVALUE(global->ofs), valuebuf, sizeof(valuebuf) ) );
+ Con_Printf( "%s: %s\n", Cmd_Argv(cmd, 2), PRVM_ValueString( prog, (etype_t)global->type, PRVM_GLOBALFIELDVALUE(global->ofs), valuebuf, sizeof(valuebuf) ) );
}
/*
PRVM_GlobalSet
===============
*/
-static void PRVM_GlobalSet_f(void)
+static void PRVM_GlobalSet_f(cmd_state_t *cmd)
{
prvm_prog_t *prog;
- ddef_t *global;
- if( Cmd_Argc() != 4 ) {
+ mdef_t *global;
+ if( Cmd_Argc(cmd) != 4 ) {
Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
return;
}
- if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(1))))
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
return;
- global = PRVM_ED_FindGlobal( prog, Cmd_Argv(2) );
+ global = PRVM_ED_FindGlobal( prog, Cmd_Argv(cmd, 2) );
if( !global )
- Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+ Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
+ else
+ PRVM_ED_ParseEpair( prog, NULL, global, Cmd_Argv(cmd, 3), true );
+}
+
+/*
+======================
+Break- and Watchpoints
+======================
+*/
+typedef struct
+{
+ char break_statement[256];
+ char watch_global[256];
+ int watch_edict;
+ char watch_field[256];
+}
+debug_data_t;
+static debug_data_t debug_data[PRVM_PROG_MAX];
+
+void PRVM_Breakpoint(prvm_prog_t *prog, int stack_index, const char *text)
+{
+ char vabuf[1024];
+ Con_Printf("PRVM_Breakpoint: %s\n", text);
+ PRVM_PrintState(prog, stack_index);
+ if (prvm_breakpointdump.integer)
+ SV_Savegame_to(prog, va(vabuf, sizeof(vabuf), "breakpoint-%s.dmp", prog->name));
+}
+
+void PRVM_Watchpoint(prvm_prog_t *prog, int stack_index, const char *text, etype_t type, prvm_eval_t *o, prvm_eval_t *n)
+{
+ size_t sz = sizeof(prvm_vec_t) * ((type & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
+ if (memcmp(o, n, sz))
+ {
+ char buf[1024];
+ char valuebuf_o[128];
+ char valuebuf_n[128];
+ PRVM_UglyValueString(prog, type, o, valuebuf_o, sizeof(valuebuf_o));
+ PRVM_UglyValueString(prog, type, n, valuebuf_n, sizeof(valuebuf_n));
+ dpsnprintf(buf, sizeof(buf), "%s: %s -> %s", text, valuebuf_o, valuebuf_n);
+ PRVM_Breakpoint(prog, stack_index, buf);
+ memcpy(o, n, sz);
+ }
+}
+
+static void PRVM_UpdateBreakpoints(prvm_prog_t *prog)
+{
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ if (!prog->loaded)
+ return;
+ if (debug->break_statement[0])
+ {
+ if (debug->break_statement[0] >= '0' && debug->break_statement[0] <= '9')
+ {
+ prog->break_statement = atoi(debug->break_statement);
+ prog->break_stack_index = 0;
+ }
+ else
+ {
+ mfunction_t *func;
+ func = PRVM_ED_FindFunction (prog, debug->break_statement);
+ if (!func)
+ {
+ Con_Printf("%s progs: no function or statement named %s to break on!\n", prog->name, debug->break_statement);
+ prog->break_statement = -1;
+ }
+ else
+ {
+ prog->break_statement = func->first_statement;
+ prog->break_stack_index = 1;
+ }
+ }
+ if (prog->break_statement >= -1)
+ Con_Printf("%s progs: breakpoint is at statement %d\n", prog->name, prog->break_statement);
+ }
else
- PRVM_ED_ParseEpair( prog, NULL, global, Cmd_Argv(3), true );
+ prog->break_statement = -1;
+
+ if (debug->watch_global[0])
+ {
+ mdef_t *global = PRVM_ED_FindGlobal( prog, debug->watch_global );
+ if( !global )
+ {
+ Con_Printf( "%s progs: no global named '%s' to watch!\n", prog->name, debug->watch_global );
+ prog->watch_global_type = ev_void;
+ }
+ else
+ {
+ size_t sz = sizeof(prvm_vec_t) * ((global->type & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
+ prog->watch_global = global->ofs;
+ prog->watch_global_type = (etype_t)global->type;
+ memcpy(&prog->watch_global_value, PRVM_GLOBALFIELDVALUE(prog->watch_global), sz);
+ }
+ if (prog->watch_global_type != ev_void)
+ Con_Printf("%s progs: global watchpoint is at global index %d\n", prog->name, prog->watch_global);
+ }
+ else
+ prog->watch_global_type = ev_void;
+
+ if (debug->watch_field[0])
+ {
+ mdef_t *field = PRVM_ED_FindField( prog, debug->watch_field );
+ if( !field )
+ {
+ Con_Printf( "%s progs: no field named '%s' to watch!\n", prog->name, debug->watch_field );
+ prog->watch_field_type = ev_void;
+ }
+ else
+ {
+ size_t sz = sizeof(prvm_vec_t) * ((field->type & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
+ prog->watch_edict = debug->watch_edict;
+ prog->watch_field = field->ofs;
+ prog->watch_field_type = (etype_t)field->type;
+ if (prog->watch_edict < prog->num_edicts)
+ memcpy(&prog->watch_edictfield_value, PRVM_EDICTFIELDVALUE(PRVM_EDICT_NUM(prog->watch_edict), prog->watch_field), sz);
+ else
+ memset(&prog->watch_edictfield_value, 0, sz);
+ }
+ if (prog->watch_edict != ev_void)
+ Con_Printf("%s progs: edict field watchpoint is at edict %d field index %d\n", prog->name, prog->watch_edict, prog->watch_field);
+ }
+ else
+ prog->watch_field_type = ev_void;
+}
+
+static void PRVM_Breakpoint_f(cmd_state_t *cmd)
+{
+ prvm_prog_t *prog;
+
+ if( Cmd_Argc(cmd) == 2 ) {
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ debug->break_statement[0] = 0;
+ }
+ PRVM_UpdateBreakpoints(prog);
+ return;
+ }
+ if( Cmd_Argc(cmd) != 3 ) {
+ Con_Printf( "prvm_breakpoint <program name> <function name | statement>\n" );
+ return;
+ }
+
+ if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ strlcpy(debug->break_statement, Cmd_Argv(cmd, 2), sizeof(debug->break_statement));
+ }
+ PRVM_UpdateBreakpoints(prog);
+}
+
+static void PRVM_GlobalWatchpoint_f(cmd_state_t *cmd)
+{
+ prvm_prog_t *prog;
+
+ if( Cmd_Argc(cmd) == 2 ) {
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ debug->watch_global[0] = 0;
+ }
+ PRVM_UpdateBreakpoints(prog);
+ return;
+ }
+ if( Cmd_Argc(cmd) != 3 ) {
+ Con_Printf( "prvm_globalwatchpoint <program name> <global name>\n" );
+ return;
+ }
+
+ if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ strlcpy(debug->watch_global, Cmd_Argv(cmd, 2), sizeof(debug->watch_global));
+ }
+ PRVM_UpdateBreakpoints(prog);
+}
+
+static void PRVM_EdictWatchpoint_f(cmd_state_t *cmd)
+{
+ prvm_prog_t *prog;
+
+ if( Cmd_Argc(cmd) == 2 ) {
+ if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ debug->watch_field[0] = 0;
+ }
+ PRVM_UpdateBreakpoints(prog);
+ return;
+ }
+ if( Cmd_Argc(cmd) != 4 ) {
+ Con_Printf( "prvm_edictwatchpoint <program name> <edict number> <field name>\n" );
+ return;
+ }
+
+ if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
+ return;
+
+ {
+ debug_data_t *debug = &debug_data[prog - prvm_prog_list];
+ debug->watch_edict = atoi(Cmd_Argv(cmd, 2));
+ strlcpy(debug->watch_field, Cmd_Argv(cmd, 3), sizeof(debug->watch_field));
+ }
+ PRVM_UpdateBreakpoints(prog);
}
/*
*/
void PRVM_Init (void)
{
- Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls");
- Cmd_AddCommand ("prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)");
- Cmd_AddCommand ("prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console");
- Cmd_AddCommand ("prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console");
- Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
- Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
- Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
- Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
+ unsigned int i;
+
+ Cmd_AddCommand(CF_SHARED, "prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls");
+ Cmd_AddCommand(CF_SHARED, "prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console");
+ Cmd_AddCommand(CF_SHARED, "prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console");
+ Cmd_AddCommand(CF_SHARED, "prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
+ Cmd_AddCommand(CF_SHARED, "cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
+ Cmd_AddCommand(CF_SHARED, "menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
+ Cmd_AddCommand(CF_SHARED, "sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
+ Cmd_AddCommand(CF_SHARED, "prvm_breakpoint", PRVM_Breakpoint_f, "marks a statement or function as breakpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear breakpoint");
+ Cmd_AddCommand(CF_SHARED, "prvm_globalwatchpoint", PRVM_GlobalWatchpoint_f, "marks a global as watchpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear watchpoint");
+ Cmd_AddCommand(CF_SHARED, "prvm_edictwatchpoint", PRVM_EdictWatchpoint_f, "marks an entity field as watchpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear watchpoint");
Cvar_RegisterVariable (&prvm_language);
Cvar_RegisterVariable (&prvm_traceqc);
Cvar_RegisterVariable (&prvm_statementprofiling);
Cvar_RegisterVariable (&prvm_timeprofiling);
+ Cvar_RegisterVariable (&prvm_coverage);
Cvar_RegisterVariable (&prvm_backtraceforwarnings);
Cvar_RegisterVariable (&prvm_leaktest);
+ Cvar_RegisterVariable (&prvm_leaktest_follow_targetname);
Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
Cvar_RegisterVariable (&prvm_errordump);
+ Cvar_RegisterVariable (&prvm_breakpointdump);
Cvar_RegisterVariable (&prvm_reuseedicts_startuptime);
Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe);
+ Cvar_RegisterVariable (&prvm_garbagecollection_enable);
+ Cvar_RegisterVariable (&prvm_garbagecollection_notify);
+ Cvar_RegisterVariable (&prvm_garbagecollection_scan_limit);
+ Cvar_RegisterVariable (&prvm_garbagecollection_strings);
+ Cvar_RegisterVariable (&prvm_stringdebug);
// COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
- prvm_runawaycheck = !COM_CheckParm("-norunaway");
+ prvm_runawaycheck = !Sys_CheckParm("-norunaway");
//VM_Cmd_Init();
+
+ // LadyHavoc: report supported extensions
+ Con_DPrintf("\nQuakeC extensions for server and client:");
+ for (i = 0; vm_sv_extensions[i]; i++)
+ Con_DPrintf(" %s", vm_sv_extensions[i]);
+ Con_DPrintf("\n");
+#ifdef CONFIG_MENU
+ Con_DPrintf("\nQuakeC extensions for menu:");
+ for (i = 0; vm_m_extensions[i]; i++)
+ Con_DPrintf(" %s", vm_m_extensions[i]);
+ Con_DPrintf("\n");
+#endif
}
/*
PRVM_InitProg
===============
*/
-void PRVM_Prog_Init(prvm_prog_t *prog)
+void PRVM_Prog_Init(prvm_prog_t *prog, cmd_state_t *cmd)
{
- if (prog->loaded)
- PRVM_Prog_Reset(prog);
-
- memset(prog, 0, sizeof(prvm_prog_t));
+ PRVM_Prog_Reset(prog);
prog->leaktest_active = prvm_leaktest.integer != 0;
+ prog->console_cmd = cmd;
}
-// LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
+// LadyHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
unsigned int PRVM_EDICT_NUM_ERROR(prvm_prog_t *prog, unsigned int n, const char *filename, int fileline)
{
prog->error_cmd("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", prog->name, n, filename, fileline);
if (num < 0)
{
// invalid
- VM_Warning(prog, "PRVM_GetString: Invalid string offset (%i < 0)\n", num);
+ if (prvm_stringdebug.integer)
+ VM_Warning(prog, "PRVM_GetString: Invalid string offset (%i < 0)\n", num);
return "";
}
else if (num < prog->stringssize)
return (char *)prog->tempstringsbuf.data + num;
else
{
- VM_Warning(prog, "PRVM_GetString: Invalid temp-string offset (%i >= %i prog->tempstringsbuf.cursize)\n", num, prog->tempstringsbuf.cursize);
+ if (prvm_stringdebug.integer)
+ VM_Warning(prog, "PRVM_GetString: Invalid temp-string offset (%i >= %i prog->tempstringsbuf.cursize)\n", num, prog->tempstringsbuf.cursize);
return "";
}
}
{
if (!prog->knownstrings[num])
{
- VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
+ if (prvm_stringdebug.integer)
+ VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
return "";
}
+ // refresh the garbage collection on the string - this guards
+ // against a certain sort of repeated migration to earlier
+ // points in the scan that could otherwise result in the string
+ // being freed for being unused
+ prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] & ~KNOWNSTRINGFLAG_GCPRUNE) | KNOWNSTRINGFLAG_GCMARK;
return prog->knownstrings[num];
}
else
{
- VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings);
+ if (prvm_stringdebug.integer)
+ VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings);
return "";
}
}
else
{
// invalid string offset
- VM_Warning(prog, "PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
+ if (prvm_stringdebug.integer)
+ VM_Warning(prog, "PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
return "";
}
}
{
const char *old;
i = i - PRVM_KNOWNSTRINGBASE;
- if(i < 0 || i >= prog->numknownstrings)
- prog->error_cmd("PRVM_ChangeEngineString: s is not an engine string");
+ if (i < 0 || i >= prog->numknownstrings)
+ prog->error_cmd("PRVM_ChangeEngineString: string index %i is out of bounds", i);
+ else if ((prog->knownstrings_flags[i] & KNOWNSTRINGFLAG_ENGINE) == 0)
+ prog->error_cmd("PRVM_ChangeEngineString: string index %i is not an engine string", i);
old = prog->knownstrings[i];
prog->knownstrings[i] = s;
return old;
}
-int PRVM_SetEngineString(prvm_prog_t *prog, const char *s)
+static void PRVM_NewKnownString(prvm_prog_t *prog, int i, int flags, const char *s)
{
- int i;
- if (!s)
- return 0;
- if (s >= prog->strings && s <= prog->strings + prog->stringssize)
- prog->error_cmd("PRVM_SetEngineString: s in prog->strings area");
- // if it's in the tempstrings area, use a reserved range
- // (otherwise we'd get millions of useless string offsets cluttering the database)
- if (s >= (char *)prog->tempstringsbuf.data && s < (char *)prog->tempstringsbuf.data + prog->tempstringsbuf.maxsize)
- return prog->stringssize + (s - (char *)prog->tempstringsbuf.data);
- // see if it's a known string address
- for (i = 0;i < prog->numknownstrings;i++)
- if (prog->knownstrings[i] == s)
- return PRVM_KNOWNSTRINGBASE + i;
- // new unknown engine string
- if (developer_insane.integer)
- Con_DPrintf("new engine string %p = \"%s\"\n", s, s);
- for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
- if (!prog->knownstrings[i])
- break;
if (i >= prog->numknownstrings)
{
if (i >= prog->maxknownstrings)
{
const char **oldstrings = prog->knownstrings;
- const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
+ const unsigned char *oldstrings_flags = prog->knownstrings_flags;
const char **oldstrings_origin = prog->knownstrings_origin;
prog->maxknownstrings += 128;
prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
- prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
- if(prog->leaktest_active)
+ prog->knownstrings_flags = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
+ if (prog->leaktest_active)
prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
if (prog->numknownstrings)
{
memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
- memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
- if(prog->leaktest_active)
+ memcpy((char **)prog->knownstrings_flags, oldstrings_flags, prog->numknownstrings * sizeof(unsigned char));
+ if (prog->leaktest_active)
memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
}
}
}
prog->firstfreeknownstring = i + 1;
prog->knownstrings[i] = s;
- prog->knownstrings_freeable[i] = false;
- if(prog->leaktest_active)
+ // it's in use right now, spare it until the next gc pass - that said, it is not freeable so this is probably moot
+ prog->knownstrings_flags[i] = flags;
+ if (prog->leaktest_active)
prog->knownstrings_origin[i] = NULL;
+}
+
+int PRVM_SetEngineString(prvm_prog_t *prog, const char *s)
+{
+ int i;
+ if (!s)
+ return 0;
+ if (s >= prog->strings && s <= prog->strings + prog->stringssize)
+ prog->error_cmd("PRVM_SetEngineString: s in prog->strings area");
+ // if it's in the tempstrings area, use a reserved range
+ // (otherwise we'd get millions of useless string offsets cluttering the database)
+ if (s >= (char *)prog->tempstringsbuf.data && s < (char *)prog->tempstringsbuf.data + prog->tempstringsbuf.maxsize)
+ return prog->stringssize + (s - (char *)prog->tempstringsbuf.data);
+ // see if it's a known string address
+ for (i = 0;i < prog->numknownstrings;i++)
+ if (prog->knownstrings[i] == s)
+ return PRVM_KNOWNSTRINGBASE + i;
+ // new unknown engine string
+ if (developer_insane.integer)
+ Con_DPrintf("new engine string %p = \"%s\"\n", (void *)s, s);
+ for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
+ if (!prog->knownstrings[i])
+ break;
+ PRVM_NewKnownString(prog, i, KNOWNSTRINGFLAG_GCMARK | KNOWNSTRINGFLAG_ENGINE, s);
return PRVM_KNOWNSTRINGBASE + i;
}
{
Con_DPrintf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, prog->tempstringsbuf.maxsize/1024);
prog->tempstringsbuf.data = (unsigned char *) Mem_Alloc(prog->progs_mempool, prog->tempstringsbuf.maxsize);
- if (old.cursize)
- memcpy(prog->tempstringsbuf.data, old.data, old.cursize);
if (old.data)
+ {
+ if (old.cursize)
+ memcpy(prog->tempstringsbuf.data, old.data, old.cursize);
Mem_Free(old.data);
+ }
}
}
t = (char *)prog->tempstringsbuf.data + prog->tempstringsbuf.cursize;
int PRVM_AllocString(prvm_prog_t *prog, size_t bufferlength, char **pointer)
{
int i;
+ char *s;
if (!bufferlength)
+ {
+ if (pointer)
+ *pointer = NULL;
return 0;
+ }
for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
if (!prog->knownstrings[i])
break;
- if (i >= prog->numknownstrings)
- {
- if (i >= prog->maxknownstrings)
- {
- const char **oldstrings = prog->knownstrings;
- const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
- const char **oldstrings_origin = prog->knownstrings_origin;
- prog->maxknownstrings += 128;
- prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
- prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
- if(prog->leaktest_active)
- prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
- if (prog->numknownstrings)
- {
- memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
- memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
- if(prog->leaktest_active)
- memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
- }
- if (oldstrings)
- Mem_Free((char **)oldstrings);
- if (oldstrings_freeable)
- Mem_Free((unsigned char *)oldstrings_freeable);
- if (oldstrings_origin)
- Mem_Free((char **)oldstrings_origin);
- }
- prog->numknownstrings++;
- }
- prog->firstfreeknownstring = i + 1;
- prog->knownstrings[i] = (char *)PRVM_Alloc(bufferlength);
- prog->knownstrings_freeable[i] = true;
+ s = (char *)PRVM_Alloc(bufferlength);
+ PRVM_NewKnownString(prog, i, KNOWNSTRINGFLAG_GCMARK, s);
if(prog->leaktest_active)
prog->knownstrings_origin[i] = PRVM_AllocationOrigin(prog);
if (pointer)
num = num - PRVM_KNOWNSTRINGBASE;
if (!prog->knownstrings[num])
prog->error_cmd("PRVM_FreeString: attempt to free a non-existent or already freed string");
- if (!prog->knownstrings_freeable[num])
+ if (!prog->knownstrings_flags[num])
prog->error_cmd("PRVM_FreeString: attempt to free a string owned by the engine");
PRVM_Free((char *)prog->knownstrings[num]);
if(prog->leaktest_active)
if(prog->knownstrings_origin[num])
PRVM_Free((char *)prog->knownstrings_origin[num]);
prog->knownstrings[num] = NULL;
- prog->knownstrings_freeable[num] = false;
+ prog->knownstrings_flags[num] = 0;
prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
}
else
prog->error_cmd("PRVM_FreeString: invalid string offset %i", num);
}
-static qboolean PRVM_IsStringReferenced(prvm_prog_t *prog, string_t string)
+static qbool PRVM_IsStringReferenced(prvm_prog_t *prog, string_t string)
{
int i, j;
for (i = 0;i < prog->numglobaldefs;i++)
{
- ddef_t *d = &prog->globaldefs[i];
+ mdef_t *d = &prog->globaldefs[i];
if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
continue;
if(string == PRVM_GLOBALFIELDSTRING(d->ofs))
for(j = 0; j < prog->num_edicts; ++j)
{
prvm_edict_t *ed = PRVM_EDICT_NUM(j);
- if (ed->priv.required->free)
+ if (ed->free)
continue;
for (i=0; i<prog->numfielddefs; ++i)
{
- ddef_t *d = &prog->fielddefs[i];
+ mdef_t *d = &prog->fielddefs[i];
if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
continue;
if(string == PRVM_EDICTFIELDSTRING(ed, d->ofs))
return false;
}
-static qboolean PRVM_IsEdictRelevant(prvm_prog_t *prog, prvm_edict_t *edict)
+static qbool PRVM_IsEdictRelevant(prvm_prog_t *prog, prvm_edict_t *edict)
{
char vabuf[1024];
char vabuf2[1024];
if(PRVM_NUM_FOR_EDICT(edict) <= prog->reserved_edicts)
return true; // world or clients
+ if (edict->freetime <= prog->inittime)
+ return true; // created during startup
if (prog == SVVM_prog)
{
if(PRVM_serveredictfloat(edict, solid)) // can block other stuff, or is a trigger?
return false;
}
-static qboolean PRVM_IsEdictReferenced(prvm_prog_t *prog, prvm_edict_t *edict, int mark)
+static qbool PRVM_IsEdictReferenced(prvm_prog_t *prog, prvm_edict_t *edict, int mark)
{
int i, j;
int edictnum = PRVM_NUM_FOR_EDICT(edict);
const char *targetname = NULL;
- if (prog == SVVM_prog)
+ if (prog == SVVM_prog && prvm_leaktest_follow_targetname.integer)
targetname = PRVM_GetString(prog, PRVM_serveredictstring(edict, targetname));
if(targetname)
if(!*targetname) // ""
targetname = NULL;
- if(mark == 0)
- {
- for (i = 0;i < prog->numglobaldefs;i++)
- {
- ddef_t *d = &prog->globaldefs[i];
- if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
- continue;
- if(edictnum == PRVM_GLOBALFIELDEDICT(d->ofs))
- return true;
- }
- }
-
for(j = 0; j < prog->num_edicts; ++j)
{
prvm_edict_t *ed = PRVM_EDICT_NUM(j);
}
for (i=0; i<prog->numfielddefs; ++i)
{
- ddef_t *d = &prog->fielddefs[i];
+ mdef_t *d = &prog->fielddefs[i];
if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
continue;
if(edictnum == PRVM_EDICTFIELDEDICT(ed, d->ofs))
static void PRVM_MarkReferencedEdicts(prvm_prog_t *prog)
{
- int j;
- qboolean found_new;
+ int i, j;
+ qbool found_new;
int stage;
+ // Stage 1: world, all entities that are relevant, and all entities that are referenced by globals.
+ stage = 1;
for(j = 0; j < prog->num_edicts; ++j)
{
prvm_edict_t *ed = PRVM_EDICT_NUM(j);
- if(ed->priv.required->free)
+ if(ed->free)
+ continue;
+ ed->priv.required->mark = PRVM_IsEdictRelevant(prog, ed) ? stage : 0;
+ }
+ for (i = 0;i < prog->numglobaldefs;i++)
+ {
+ mdef_t *d = &prog->globaldefs[i];
+ prvm_edict_t *ed;
+ if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
+ continue;
+ j = PRVM_GLOBALFIELDEDICT(d->ofs);
+ if (i < 0 || j >= prog->max_edicts) {
+ Con_Printf("Invalid entity reference from global %s.\n", PRVM_GetString(prog, d->s_name));
continue;
- ed->priv.required->mark = PRVM_IsEdictRelevant(prog, ed) ? 1 : 0;
+ }
+ ed = PRVM_EDICT_NUM(j);;
+ ed->priv.required->mark = stage;
}
- stage = 1;
+ // Future stages: all entities that are referenced by an entity of the previous stage.
do
{
found_new = false;
for(j = 0; j < prog->num_edicts; ++j)
{
prvm_edict_t *ed = PRVM_EDICT_NUM(j);
- if(ed->priv.required->free)
+ if(ed->free)
continue;
if(ed->priv.required->mark)
continue;
void PRVM_LeakTest(prvm_prog_t *prog)
{
int i, j;
- qboolean leaked = false;
+ qbool leaked = false;
if(!prog->leaktest_active)
return;
for (i = 0; i < prog->numknownstrings; ++i)
{
if(prog->knownstrings[i])
- if(prog->knownstrings_freeable[i])
+ if(prog->knownstrings_flags[i])
if(prog->knownstrings_origin[i])
if(!PRVM_IsStringReferenced(prog, PRVM_KNOWNSTRINGBASE + i))
{
for(j = 0; j < prog->num_edicts; ++j)
{
prvm_edict_t *ed = PRVM_EDICT_NUM(j);
- if(ed->priv.required->free)
+ if(ed->free)
continue;
if(!ed->priv.required->mark)
if(ed->priv.required->allocation_origin)
if(!leaked)
Con_Printf("Congratulations. No leaks found.\n");
}
+
+void PRVM_GarbageCollection(prvm_prog_t *prog)
+{
+ int limit = prvm_garbagecollection_scan_limit.integer;
+ prvm_prog_garbagecollection_state_t *gc = &prog->gc;
+ if (!prvm_garbagecollection_enable.integer)
+ return;
+ // philosophy:
+ // we like to limit how much scanning we do so it doesn't put a significant
+ // burden on the cpu, so each of these are not complete scans, we also like
+ // to have consistent cpu usage so we do a bit of work on each category of
+ // leaked object every frame
+ switch (gc->stage)
+ {
+ case PRVM_GC_START:
+ gc->stage++;
+ break;
+ case PRVM_GC_GLOBALS_MARK:
+ for (; gc->globals_mark_progress < prog->numglobaldefs && (limit--) > 0; gc->globals_mark_progress++)
+ {
+ mdef_t *d = &prog->globaldefs[gc->globals_mark_progress];
+ switch (d->type)
+ {
+ case ev_string:
+ {
+ prvm_int_t s = prog->globals.ip[d->ofs];
+ if (s & PRVM_KNOWNSTRINGBASE)
+ {
+ prvm_int_t num = s - PRVM_KNOWNSTRINGBASE;
+ if (!prog->knownstrings[num])
+ {
+ // invalid
+ Con_DPrintf("PRVM_GarbageCollection: Found bogus strzone reference in global %i (global name: \"%s\"), erasing reference", d->ofs, PRVM_GetString(prog, d->s_name));
+ prog->globals.ip[d->ofs] = 0;
+ continue;
+ }
+ prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] | KNOWNSTRINGFLAG_GCMARK) & ~KNOWNSTRINGFLAG_GCPRUNE;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ if (gc->globals_mark_progress >= prog->numglobaldefs)
+ gc->stage++;
+ break;
+ case PRVM_GC_FIELDS_MARK:
+ for (; gc->fields_mark_progress < prog->numfielddefs && limit > 0;)
+ {
+ mdef_t *d = &prog->fielddefs[gc->fields_mark_progress];
+ switch (d->type)
+ {
+ case ev_string:
+ //for (gc-> entityindex = 0; entityindex < prog->num_edicts; entityindex++)
+ for (;gc->fields_mark_progress_entity < prog->num_edicts && (limit--) > 0;gc->fields_mark_progress_entity++)
+ {
+ int entityindex = gc->fields_mark_progress_entity;
+ prvm_int_t s = prog->edictsfields.ip[entityindex * prog->entityfields + d->ofs];
+ if (s & PRVM_KNOWNSTRINGBASE)
+ {
+ prvm_int_t num = s - PRVM_KNOWNSTRINGBASE;
+ if (!prog->knownstrings[num])
+ {
+ // invalid
+ Con_DPrintf("PRVM_GarbageCollection: Found bogus strzone reference in edict %i field %i (field name: \"%s\"), erasing reference", entityindex, d->ofs, PRVM_GetString(prog, d->s_name));
+ prog->edictsfields.ip[entityindex * prog->entityfields + d->ofs] = 0;
+ continue;
+ }
+ prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] | KNOWNSTRINGFLAG_GCMARK) & ~KNOWNSTRINGFLAG_GCPRUNE;
+ }
+ }
+ if (gc->fields_mark_progress_entity >= prog->num_edicts)
+ {
+ gc->fields_mark_progress_entity = 0;
+ gc->fields_mark_progress++;
+ }
+ break;
+ default:
+ gc->fields_mark_progress_entity = 0;
+ gc->fields_mark_progress++;
+ break;
+ }
+ }
+ if (gc->fields_mark_progress >= prog->numfielddefs)
+ gc->stage++;
+ break;
+ case PRVM_GC_KNOWNSTRINGS_SWEEP:
+ // free any strzone'd strings that are not marked
+ if (!prvm_garbagecollection_strings.integer)
+ {
+ gc->stage++;
+ break;
+ }
+ for (;gc->knownstrings_sweep_progress < prog->numknownstrings && (limit--) > 0;gc->knownstrings_sweep_progress++)
+ {
+ int num = gc->knownstrings_sweep_progress;
+ if (prog->knownstrings[num] && (prog->knownstrings_flags[num] & (KNOWNSTRINGFLAG_GCMARK | KNOWNSTRINGFLAG_ENGINE)) == 0)
+ {
+ if (prog->knownstrings_flags[num] & KNOWNSTRINGFLAG_GCPRUNE)
+ {
+ // string has been marked for pruning two passes in a row
+ if (prvm_garbagecollection_notify.integer)
+ Con_DPrintf("prvm_garbagecollection_notify: %s: freeing unreferenced string %i: \"%s\"\n", prog->name, num, prog->knownstrings[num]);
+ Mem_Free((char *)prog->knownstrings[num]);
+ prog->knownstrings[num] = NULL;
+ prog->knownstrings_flags[num] = 0;
+ prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
+ }
+ else
+ {
+ // mark it for pruning next pass
+ prog->knownstrings_flags[num] |= KNOWNSTRINGFLAG_GCPRUNE;
+ }
+ }
+ }
+ if (gc->knownstrings_sweep_progress >= prog->numknownstrings)
+ gc->stage++;
+ break;
+ case PRVM_GC_RESET:
+ default:
+ memset(gc, 0, sizeof(*gc));
+ }
+}