ddef_t *PRVM_ED_FieldAtOfs(int ofs);
qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash);
-// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
-#ifdef PRVM_BOUNDSCHECK_CVAR
-cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1", "enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer)"};
-#endif
// 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_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 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_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"};
+
+qboolean prvm_runawaycheck = true;
+
+// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
+// enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer)
+qboolean prvm_boundscheck = true;
extern sizebuf_t vm_tempstringsbuf;
line[i++] = '\\';
line[i++] = '\\';
}
+ else if (*s == '"')
+ {
+ line[i++] = '\\';
+ line[i++] = '"';
+ }
else
line[i++] = *s;
s++;
For savegames
=============
*/
+extern cvar_t developer_entityparsing;
void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
{
ddef_t *d;
{
d = &prog->fielddefs[i];
name = PRVM_GetString(d->s_name);
+
+ if(developer_entityparsing.integer)
+ Con_Printf("PRVM_ED_Write: at entity %d field %s\n", PRVM_NUM_FOR_EDICT(ed), name);
+
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
continue;
FS_Printf(f,"\"%s\" ",name);
+ prog->statestring = va("PRVM_ED_Write, ent=%d, name=%s", i, name);
FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
+ prog->statestring = NULL;
}
FS_Print(f, "}\n");
continue;
name = PRVM_GetString(def->s_name);
+
+ if(developer_entityparsing.integer)
+ Con_Printf("PRVM_ED_WriteGlobals: at global %s\n", name);
+
+ prog->statestring = va("PRVM_ED_WriteGlobals, name=%s", name);
FS_Printf(f,"\"%s\" ", name);
FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
+ prog->statestring = NULL;
}
FS_Print(f,"}\n");
}
if (com_token[0] == '}')
break;
+ if (developer_entityparsing.integer)
+ Con_Printf("Key: \"%s\"", com_token);
+
strlcpy (keyname, com_token, sizeof(keyname));
// parse value
if (!COM_ParseToken_Simple(&data, false, true))
PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
+ if (developer_entityparsing.integer)
+ Con_Printf(" \"%s\"\n", com_token);
+
if (com_token[0] == '}')
PRVM_ERROR ("PRVM_ED_ParseGlobals: closing brace without data");
break;
case ev_float:
- while (*s && *s <= ' ')
+ while (*s && ISWHITESPACE(*s))
s++;
val->_float = atof(s);
break;
case ev_vector:
for (i = 0;i < 3;i++)
{
- while (*s && *s <= ' ')
+ while (*s && ISWHITESPACE(*s))
s++;
if (!*s)
break;
val->vector[i] = atof(s);
- while (*s > ' ')
+ while (!ISWHITESPACE(*s))
s++;
if (!*s)
break;
break;
case ev_entity:
- while (*s && *s <= ' ')
+ while (*s && ISWHITESPACE(*s))
s++;
i = atoi(s);
if (i >= prog->limit_edicts)
Used for initial level load and for savegames.
====================
*/
-extern cvar_t developer_entityparsing;
const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
{
ddef_t *key;
continue;
}
+ if (prog->funcoffsets.SV_OnEntityPreSpawnFunction)
+ {
+ // self = ent
+ PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPreSpawnFunction, "QC function SV_OnEntityPreSpawnFunction is missing");
+ }
+
+ if(ent->priv.required->free)
+ {
+ inhibited++;
+ continue;
+ }
+
//
// immediately call spawn function, but only if there is a self global and a classname
//
+ if(!ent->priv.required->free)
if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0)
{
string_t handle = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string;
PRVM_ED_Print(ent, NULL);
}
PRVM_ED_Free (ent);
- continue;
+ continue; // not included in "inhibited" count
}
}
else
}
}
+ if(!ent->priv.required->free)
+ if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
+ {
+ // self = ent
+ PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
+ }
+
spawned++;
if (ent->priv.required->free)
died++;
// server and client qc use a lot of similar fields, so this is combined
prog->fieldoffsets.SendEntity = PRVM_ED_FindFieldOffset("SendEntity");
+ prog->fieldoffsets.SendFlags = PRVM_ED_FindFieldOffset("SendFlags");
prog->fieldoffsets.Version = PRVM_ED_FindFieldOffset("Version");
prog->fieldoffsets.alpha = PRVM_ED_FindFieldOffset("alpha");
prog->fieldoffsets.ammo_cells1 = PRVM_ED_FindFieldOffset("ammo_cells1");
prog->fieldoffsets.buttonuse = PRVM_ED_FindFieldOffset("buttonuse");
prog->fieldoffsets.chain = PRVM_ED_FindFieldOffset("chain");
prog->fieldoffsets.classname = PRVM_ED_FindFieldOffset("classname");
+ prog->fieldoffsets.clientcamera = PRVM_ED_FindFieldOffset("clientcamera");
prog->fieldoffsets.clientcolors = PRVM_ED_FindFieldOffset("clientcolors");
+ prog->fieldoffsets.clientstatus = PRVM_ED_FindFieldOffset("clientstatus");
prog->fieldoffsets.color = PRVM_ED_FindFieldOffset("color");
prog->fieldoffsets.colormod = PRVM_ED_FindFieldOffset("colormod");
prog->fieldoffsets.contentstransition = PRVM_ED_FindFieldOffset("contentstransition");
prog->fieldoffsets.frame1time = PRVM_ED_FindFieldOffset("frame1time");
prog->fieldoffsets.frame2 = PRVM_ED_FindFieldOffset("frame2");
prog->fieldoffsets.frame2time = PRVM_ED_FindFieldOffset("frame2time");
+ prog->fieldoffsets.frame3 = PRVM_ED_FindFieldOffset("frame3");
+ prog->fieldoffsets.frame3time = PRVM_ED_FindFieldOffset("frame3time");
+ prog->fieldoffsets.frame4 = PRVM_ED_FindFieldOffset("frame4");
+ prog->fieldoffsets.frame4time = PRVM_ED_FindFieldOffset("frame4time");
prog->fieldoffsets.fullbright = PRVM_ED_FindFieldOffset("fullbright");
prog->fieldoffsets.glow_color = PRVM_ED_FindFieldOffset("glow_color");
prog->fieldoffsets.glow_size = PRVM_ED_FindFieldOffset("glow_size");
prog->fieldoffsets.idealpitch = PRVM_ED_FindFieldOffset("idealpitch");
prog->fieldoffsets.items2 = PRVM_ED_FindFieldOffset("items2");
prog->fieldoffsets.lerpfrac = PRVM_ED_FindFieldOffset("lerpfrac");
+ prog->fieldoffsets.lerpfrac3 = PRVM_ED_FindFieldOffset("lerpfrac3");
+ prog->fieldoffsets.lerpfrac4 = PRVM_ED_FindFieldOffset("lerpfrac4");
prog->fieldoffsets.light_lev = PRVM_ED_FindFieldOffset("light_lev");
prog->fieldoffsets.message = PRVM_ED_FindFieldOffset("message");
prog->fieldoffsets.modelflags = PRVM_ED_FindFieldOffset("modelflags");
prog->fieldoffsets.renderflags = PRVM_ED_FindFieldOffset("renderflags");
prog->fieldoffsets.rendermode = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support
prog->fieldoffsets.scale = PRVM_ED_FindFieldOffset("scale");
+ prog->fieldoffsets.shadertime = PRVM_ED_FindFieldOffset("shadertime");
prog->fieldoffsets.style = PRVM_ED_FindFieldOffset("style");
prog->fieldoffsets.tag_entity = PRVM_ED_FindFieldOffset("tag_entity");
prog->fieldoffsets.tag_index = PRVM_ED_FindFieldOffset("tag_index");
prog->fieldoffsets.viewmodelforclient = PRVM_ED_FindFieldOffset("viewmodelforclient");
prog->fieldoffsets.viewzoom = PRVM_ED_FindFieldOffset("viewzoom");
prog->fieldoffsets.yaw_speed = PRVM_ED_FindFieldOffset("yaw_speed");
- prog->fieldoffsets.clientcamera = PRVM_ED_FindFieldOffset("clientcamera");
prog->funcoffsets.CSQC_ConsoleCommand = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand");
prog->funcoffsets.CSQC_Ent_Remove = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove");
- prog->funcoffsets.CSQC_Ent_Update = PRVM_ED_FindFunctionOffset("CSQC_Ent_Update");
prog->funcoffsets.CSQC_Ent_Spawn = PRVM_ED_FindFunctionOffset("CSQC_Ent_Spawn");
+ prog->funcoffsets.CSQC_Ent_Update = PRVM_ED_FindFunctionOffset("CSQC_Ent_Update");
prog->funcoffsets.CSQC_Event = PRVM_ED_FindFunctionOffset("CSQC_Event");
prog->funcoffsets.CSQC_Event_Sound = PRVM_ED_FindFunctionOffset("CSQC_Event_Sound");
prog->funcoffsets.CSQC_Init = PRVM_ED_FindFunctionOffset("CSQC_Init");
prog->funcoffsets.CSQC_Parse_TempEntity = PRVM_ED_FindFunctionOffset("CSQC_Parse_TempEntity");
prog->funcoffsets.CSQC_Shutdown = PRVM_ED_FindFunctionOffset("CSQC_Shutdown");
prog->funcoffsets.CSQC_UpdateView = PRVM_ED_FindFunctionOffset("CSQC_UpdateView");
- prog->funcoffsets.Gecko_Query = PRVM_ED_FindFunctionOffset("Gecko_Query");
prog->funcoffsets.EndFrame = PRVM_ED_FindFunctionOffset("EndFrame");
+ prog->funcoffsets.GameCommand = PRVM_ED_FindFunctionOffset("GameCommand");
+ prog->funcoffsets.Gecko_Query = PRVM_ED_FindFunctionOffset("Gecko_Query");
prog->funcoffsets.RestoreGame = PRVM_ED_FindFunctionOffset("RestoreGame");
prog->funcoffsets.SV_ChangeTeam = PRVM_ED_FindFunctionOffset("SV_ChangeTeam");
+ prog->funcoffsets.SV_OnEntityNoSpawnFunction = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction");
+ prog->funcoffsets.SV_OnEntityPostSpawnFunction = PRVM_ED_FindFunctionOffset("SV_OnEntityPostSpawnFunction");
+ prog->funcoffsets.SV_OnEntityPreSpawnFunction = PRVM_ED_FindFunctionOffset("SV_OnEntityPreSpawnFunction");
prog->funcoffsets.SV_ParseClientCommand = PRVM_ED_FindFunctionOffset("SV_ParseClientCommand");
+ prog->funcoffsets.SV_PausedTic = PRVM_ED_FindFunctionOffset("SV_PausedTic");
prog->funcoffsets.SV_PlayerPhysics = PRVM_ED_FindFunctionOffset("SV_PlayerPhysics");
- prog->funcoffsets.SV_OnEntityNoSpawnFunction = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction");
- prog->funcoffsets.GameCommand = PRVM_ED_FindFunctionOffset("GameCommand");
prog->funcoffsets.SV_Shutdown = PRVM_ED_FindFunctionOffset("SV_Shutdown");
+ prog->funcoffsets.URI_Get_Callback = PRVM_ED_FindFunctionOffset("URI_Get_Callback");
prog->globaloffsets.SV_InitCmd = PRVM_ED_FindGlobalOffset("SV_InitCmd");
+ prog->globaloffsets.coop = PRVM_ED_FindGlobalOffset("coop");
+ prog->globaloffsets.deathmatch = PRVM_ED_FindGlobalOffset("deathmatch");
+ prog->globaloffsets.dmg_origin = PRVM_ED_FindGlobalOffset("dmg_origin");
+ prog->globaloffsets.dmg_save = PRVM_ED_FindGlobalOffset("dmg_save");
+ prog->globaloffsets.dmg_take = PRVM_ED_FindGlobalOffset("dmg_take");
+ prog->globaloffsets.drawfont = PRVM_ED_FindGlobalOffset("drawfont");
+ prog->globaloffsets.gettaginfo_forward = PRVM_ED_FindGlobalOffset("gettaginfo_forward");
+ prog->globaloffsets.gettaginfo_name = PRVM_ED_FindGlobalOffset("gettaginfo_name");
+ prog->globaloffsets.gettaginfo_offset = PRVM_ED_FindGlobalOffset("gettaginfo_offset");
+ prog->globaloffsets.gettaginfo_parent = PRVM_ED_FindGlobalOffset("gettaginfo_parent");
+ prog->globaloffsets.gettaginfo_right = PRVM_ED_FindGlobalOffset("gettaginfo_right");
+ prog->globaloffsets.gettaginfo_up = PRVM_ED_FindGlobalOffset("gettaginfo_up");
+ prog->globaloffsets.intermission = PRVM_ED_FindGlobalOffset("intermission");
+ prog->globaloffsets.require_spawnfunc_prefix = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix");
+ prog->globaloffsets.sb_showscores = PRVM_ED_FindGlobalOffset("sb_showscores");
prog->globaloffsets.self = PRVM_ED_FindGlobalOffset("self");
+ prog->globaloffsets.serverdeltatime = PRVM_ED_FindGlobalOffset("serverdeltatime");
+ prog->globaloffsets.serverprevtime = PRVM_ED_FindGlobalOffset("serverprevtime");
+ prog->globaloffsets.servertime = PRVM_ED_FindGlobalOffset("servertime");
prog->globaloffsets.time = PRVM_ED_FindGlobalOffset("time");
- prog->globaloffsets.v_forward = PRVM_ED_FindGlobalOffset("v_forward");
- prog->globaloffsets.v_right = PRVM_ED_FindGlobalOffset("v_right");
- prog->globaloffsets.v_up = PRVM_ED_FindGlobalOffset("v_up");
- prog->globaloffsets.view_angles = PRVM_ED_FindGlobalOffset("view_angles");
prog->globaloffsets.trace_allsolid = PRVM_ED_FindGlobalOffset("trace_allsolid");
- prog->globaloffsets.trace_startsolid = PRVM_ED_FindGlobalOffset("trace_startsolid");
- prog->globaloffsets.trace_fraction = PRVM_ED_FindGlobalOffset("trace_fraction");
- prog->globaloffsets.trace_inwater = PRVM_ED_FindGlobalOffset("trace_inwater");
- prog->globaloffsets.trace_inopen = PRVM_ED_FindGlobalOffset("trace_inopen");
- prog->globaloffsets.trace_endpos = PRVM_ED_FindGlobalOffset("trace_endpos");
- prog->globaloffsets.trace_plane_normal = PRVM_ED_FindGlobalOffset("trace_plane_normal");
- prog->globaloffsets.trace_plane_dist = PRVM_ED_FindGlobalOffset("trace_plane_dist");
- prog->globaloffsets.trace_ent = PRVM_ED_FindGlobalOffset("trace_ent");
prog->globaloffsets.trace_dphitcontents = PRVM_ED_FindGlobalOffset("trace_dphitcontents");
prog->globaloffsets.trace_dphitq3surfaceflags = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags");
prog->globaloffsets.trace_dphittexturename = PRVM_ED_FindGlobalOffset("trace_dphittexturename");
prog->globaloffsets.trace_dpstartcontents = PRVM_ED_FindGlobalOffset("trace_dpstartcontents");
- prog->globaloffsets.intermission = PRVM_ED_FindGlobalOffset("intermission");
- prog->globaloffsets.coop = PRVM_ED_FindGlobalOffset("coop");
- prog->globaloffsets.deathmatch = PRVM_ED_FindGlobalOffset("deathmatch");
- prog->globaloffsets.dmg_take = PRVM_ED_FindGlobalOffset("dmg_take");
- prog->globaloffsets.dmg_save = PRVM_ED_FindGlobalOffset("dmg_save");
- prog->globaloffsets.dmg_origin = PRVM_ED_FindGlobalOffset("dmg_origin");
- prog->globaloffsets.sb_showscores = PRVM_ED_FindGlobalOffset("sb_showscores");
- prog->globaloffsets.drawfont = PRVM_ED_FindGlobalOffset("drawfont");
- prog->globaloffsets.require_spawnfunc_prefix = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix");
+ prog->globaloffsets.trace_endpos = PRVM_ED_FindGlobalOffset("trace_endpos");
+ prog->globaloffsets.trace_ent = PRVM_ED_FindGlobalOffset("trace_ent");
+ prog->globaloffsets.trace_fraction = PRVM_ED_FindGlobalOffset("trace_fraction");
+ prog->globaloffsets.trace_inopen = PRVM_ED_FindGlobalOffset("trace_inopen");
+ prog->globaloffsets.trace_inwater = PRVM_ED_FindGlobalOffset("trace_inwater");
+ prog->globaloffsets.trace_networkentity = PRVM_ED_FindGlobalOffset("trace_networkentity");
+ prog->globaloffsets.trace_plane_dist = PRVM_ED_FindGlobalOffset("trace_plane_dist");
+ prog->globaloffsets.trace_plane_normal = PRVM_ED_FindGlobalOffset("trace_plane_normal");
+ prog->globaloffsets.trace_startsolid = PRVM_ED_FindGlobalOffset("trace_startsolid");
+ prog->globaloffsets.v_forward = PRVM_ED_FindGlobalOffset("v_forward");
+ prog->globaloffsets.v_right = PRVM_ED_FindGlobalOffset("v_right");
+ prog->globaloffsets.v_up = PRVM_ED_FindGlobalOffset("v_up");
+ prog->globaloffsets.view_angles = PRVM_ED_FindGlobalOffset("view_angles");
+ prog->globaloffsets.worldstatus = PRVM_ED_FindGlobalOffset("worldstatus");
// menu qc only uses some functions, nothing else
prog->funcoffsets.m_draw = PRVM_ED_FindFunctionOffset("m_draw");
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");
- // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
-#ifdef PRVM_BOUNDSCHECK_CVAR
- Cvar_RegisterVariable (&prvm_boundscheck);
-#endif
+
+ // COMMANDLINEOPTION: PRVM: -noboundscheck disables the bounds checks (security hole if CSQC is in use!)
+ prvm_boundscheck = !COM_CheckParm("-noboundscheck");
+
Cvar_RegisterVariable (&prvm_traceqc);
Cvar_RegisterVariable (&prvm_statementprofiling);
Cvar_RegisterVariable (&prvm_backtraceforwarnings);
Cvar_RegisterVariable (&prvm_leaktest);
+ Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
+ Cvar_RegisterVariable (&prvm_errordump);
+
+ // COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
+ prvm_runawaycheck = !COM_CheckParm("-norunaway");
//VM_Cmd_Init();
}
{
if (developer.integer >= 100)
Con_Printf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024);
- vm_tempstringsbuf.data = Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
+ vm_tempstringsbuf.data = (unsigned char *) Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
if (old.cursize)
memcpy(vm_tempstringsbuf.data, old.data, old.cursize);
if (old.data)
{
// TODO someone add more stuff here
cl_entvars_t *ev = edict->fields.client;
+ if(ev->entnum) // csqc networked
+ return true;
if(ev->modelindex) // visible ent?
return true;
if(ev->effects) // particle effect?
for (i = 0; i < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray); ++i)
{
- prvm_stringbuffer_t *stringbuffer = Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
+ prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
if(stringbuffer)
if(stringbuffer->origin)
{
projects / xonotic / darkplaces.git / blobdiff