X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=ea8392751e9760f2aff73c0881557e1f7c608557;hp=720bd6d17e3e986e98e33212444e3ce8bd593dd7;hb=HEAD;hpb=68cf35fc5c0db38772f437f144f2f40d18c903d5 diff --git a/prvm_edict.c b/prvm_edict.c index 720bd6d1..4b732742 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -22,6 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "progsvm.h" #include "csprogs.h" +#include "prvm_cmds.h" prvm_prog_t prvm_prog_list[PRVM_PROG_MAX]; @@ -29,29 +30,32 @@ int prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(v prvm_eval_t prvm_badvalue; // used only for error returns -cvar_t prvm_language = {CVAR_CLIENT | CVAR_SERVER | CVAR_SAVE, "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"}; +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 = {CVAR_CLIENT | CVAR_SERVER, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"}; +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 = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_SERVER, "prvm_coverage", "0", "report and count coverage events (1: per-function, 2: coverage() builtin, 4: per-statement)"}; -cvar_t prvm_backtraceforwarnings = {CVAR_CLIENT | CVAR_SERVER, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"}; -cvar_t prvm_leaktest = {CVAR_CLIENT | CVAR_SERVER, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"}; -cvar_t prvm_leaktest_follow_targetname = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_SERVER, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"}; -cvar_t prvm_breakpointdump = {CVAR_CLIENT | CVAR_SERVER, "prvm_breakpointdump", "0", "write a savegame on breakpoint to breakpoint-server.dmp"}; -cvar_t prvm_reuseedicts_startuptime = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_SERVER, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"}; -cvar_t prvm_garbagecollection_enable = {CVAR_CLIENT | CVAR_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 = {CVAR_CLIENT | CVAR_SERVER, "prvm_garbagecollection_notify", "0", "print out a notification for each resource freed by garbage collection"}; -cvar_t prvm_garbagecollection_scan_limit = {CVAR_CLIENT | CVAR_SERVER, "prvm_garbagecollection_scan_limit", "10000", "scan this many fields or resources per frame to free up unreferenced resources"}; -cvar_t prvm_garbagecollection_strings = {CVAR_CLIENT | CVAR_SERVER, "prvm_garbagecollection_strings", "1", "automatically call strunzone() on strings that are not referenced"}; -cvar_t prvm_stringdebug = {CVAR_CLIENT | CVAR_SERVER, "prvm_stringdebug", "0", "Print debug and warning messages related to strings"}; +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 (set developer >= 1 to see these)"}; +/// At 50k in Xonotic with 8 bots scans take about: 24s server, 25s menu, 9s client. +/// At 50k in Quake 1.5: 2.2s server, 0.14s client. +/// At 50k impact on high FPS benchmarks is negligible, at 100k impact is low but measurable. +cvar_t prvm_garbagecollection_scan_limit = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_scan_limit", "50000", "scan this many fields or resources per second 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 @@ -127,7 +131,7 @@ void PRVM_MEM_IncreaseEdicts(prvm_prog_t *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; @@ -136,7 +140,7 @@ int PRVM_ED_FindFieldOffset(prvm_prog_t *prog, const char *field) 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; @@ -204,8 +208,8 @@ freed and sets the allocation origin. void PRVM_ED_ClearEdict(prvm_prog_t *prog, prvm_edict_t *e) { memset(e->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t)); - e->priv.required->free = false; - e->priv.required->freetime = host.realtime; + 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); @@ -220,8 +224,9 @@ const char *PRVM_AllocationOrigin(prvm_prog_t *prog) 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(256); - PRVM_ShortStackTrace(prog, buf, 256); + // bones_was_here: this is the smallest 64 multiple that avoids truncation in Xonotic (was 256) + buf = (char *)PRVM_Alloc(448); + PRVM_ShortStackTrace(prog, buf, 448); } return buf; } @@ -233,17 +238,17 @@ PRVM_ED_CanAlloc 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 == host.realtime) return true; - if(host.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(host.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 } @@ -297,7 +302,11 @@ prvm_edict_t *PRVM_ED_Alloc(prvm_prog_t *prog) 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) @@ -308,8 +317,8 @@ 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 = host.realtime; + ed->free = true; + ed->freetime = host.realtime; if(ed->priv.required->allocation_origin) { Mem_Free((char *)ed->priv.required->allocation_origin); @@ -324,9 +333,9 @@ void PRVM_ED_Free(prvm_prog_t *prog, prvm_edict_t *ed) 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++) @@ -343,9 +352,9 @@ static ddef_t *PRVM_ED_GlobalAtOfs (prvm_prog_t *prog, int ofs) 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++) @@ -362,9 +371,9 @@ ddef_t *PRVM_ED_FieldAtOfs (prvm_prog_t *prog, int ofs) 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++) @@ -381,9 +390,9 @@ ddef_t *PRVM_ED_FindField (prvm_prog_t *prog, const char *name) 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++) @@ -395,6 +404,16 @@ ddef_t *PRVM_ED_FindGlobal (prvm_prog_t *prog, const char *name) 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; +} /* ============ @@ -425,7 +444,7 @@ Returns a string describing *data in a type specific manner */ 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; @@ -434,7 +453,7 @@ static char *PRVM_ValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val switch (type) { case ev_string: - strlcpy (line, PRVM_GetString (prog, val->string), linelength); + dp_strlcpy (line, PRVM_GetString (prog, val->string), linelength); break; case ev_entity: n = val->edict; @@ -457,18 +476,18 @@ static char *PRVM_ValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val if (def != NULL) dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name)); else - dpsnprintf (line, linelength, "field%" PRVM_PRIi " (invalid!)", val->_int ); + dpsnprintf (line, linelength, "field %" PRVM_PRIi " (invalid!)", val->_int ); break; case ev_void: dpsnprintf (line, linelength, "void"); break; case ev_float: // LadyHavoc: changed from %5.1f to %10.4f - dpsnprintf (line, linelength, FLOAT_LOSSLESS_FORMAT, val->_float); + dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float); break; case ev_vector: // LadyHavoc: changed from %5.1f to %10.4f - dpsnprintf (line, linelength, "'" VECTOR_LOSSLESS_FORMAT "'", 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; case ev_pointer: dpsnprintf (line, linelength, "pointer"); @@ -493,7 +512,7 @@ char *PRVM_UglyValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, c { int i; const char *s; - ddef_t *def; + mdef_t *def; mfunction_t *f; type = (etype_t)((int)type & ~DEF_SAVEGLOBAL); @@ -541,7 +560,7 @@ char *PRVM_UglyValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, c if ((unsigned int)val->function < (unsigned int)prog->progs_numfunctions) { f = prog->functions + val->function; - strlcpy (line, PRVM_GetString (prog, f->s_name), linelength); + dp_strlcpy (line, PRVM_GetString (prog, f->s_name), linelength); } else dpsnprintf (line, linelength, "bad function %" PRVM_PRIi " (invalid!)", val->function); @@ -557,10 +576,10 @@ char *PRVM_UglyValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, c dpsnprintf (line, linelength, "void"); break; case ev_float: - dpsnprintf (line, linelength, FLOAT_LOSSLESS_FORMAT, val->_float); + dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float); break; case ev_vector: - dpsnprintf (line, linelength, VECTOR_LOSSLESS_FORMAT, 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); @@ -582,7 +601,7 @@ char *PRVM_GlobalString (prvm_prog_t *prog, int ofs, char *line, size_t lineleng { char *s; //size_t i; - ddef_t *def; + mdef_t *def; prvm_eval_t *val; char valuebuf[MAX_INPUTLINE]; @@ -607,7 +626,7 @@ char *PRVM_GlobalString (prvm_prog_t *prog, int ofs, char *line, size_t lineleng 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) @@ -636,7 +655,7 @@ For debugging void PRVM_ED_Print(prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fieldname) { size_t l; - ddef_t *d; + mdef_t *d; prvm_eval_t *val; int i, j; const char *name; @@ -644,7 +663,7 @@ void PRVM_ED_Print(prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fie 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; @@ -683,10 +702,10 @@ void PRVM_ED_Print(prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fie tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strlcat(tempstring, name, sizeof(tempstring)); + dp_strlcat(tempstring, name, sizeof(tempstring)); for (l = strlen(name);l < 14;l++) - strlcat(tempstring, " ", sizeof(tempstring)); - strlcat(tempstring, " ", sizeof(tempstring)); + dp_strlcat(tempstring, " ", sizeof(tempstring)); + dp_strlcat(tempstring, " ", sizeof(tempstring)); name = PRVM_ValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf)); if (strlen(name) > sizeof(tempstring2)-4) @@ -696,8 +715,8 @@ void PRVM_ED_Print(prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fie tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strlcat(tempstring, name, sizeof(tempstring)); - strlcat(tempstring, "\n", sizeof(tempstring)); + dp_strlcat(tempstring, name, sizeof(tempstring)); + dp_strlcat(tempstring, "\n", sizeof(tempstring)); if (strlen(tempstring) >= sizeof(tempstring)/2) { Con_Print(tempstring); @@ -717,7 +736,7 @@ For savegames */ void PRVM_ED_Write (prvm_prog_t *prog, qfile_t *f, prvm_edict_t *ed) { - ddef_t *d; + mdef_t *d; prvm_eval_t *val; int i, j; const char *name; @@ -727,7 +746,7 @@ void PRVM_ED_Write (prvm_prog_t *prog, qfile_t *f, prvm_edict_t *ed) FS_Print(f, "{\n"); - if (ed->priv.required->free) + if (ed->free) { FS_Print(f, "}\n"); return; @@ -879,7 +898,7 @@ PRVM_ED_WriteGlobals */ void PRVM_ED_WriteGlobals (prvm_prog_t *prog, qfile_t *f) { - ddef_t *def; + mdef_t *def; int i; const char *name; int type; @@ -919,7 +938,7 @@ PRVM_ED_ParseGlobals void PRVM_ED_ParseGlobals (prvm_prog_t *prog, const char *data) { char keyname[MAX_INPUTLINE]; - ddef_t *key; + mdef_t *key; while (1) { @@ -932,7 +951,7 @@ void PRVM_ED_ParseGlobals (prvm_prog_t *prog, const char *data) if (developer_entityparsing.integer) Con_Printf("Key: \"%s\"", com_token); - strlcpy (keyname, com_token, sizeof(keyname)); + dp_strlcpy (keyname, com_token, sizeof(keyname)); // parse value if (!COM_ParseToken_Simple(&data, false, true, true)) @@ -967,11 +986,11 @@ Can parse either fields or globals 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; @@ -1108,7 +1127,7 @@ static void PRVM_GameCommand(cmd_state_t *cmd, const char *whichprogs, const cha s = Cmd_Args(cmd); restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize; - PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, s ? s : ""); + PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, s ? s : "", s ? strlen(s) : 0); prog->ExecuteProgram(prog, PRVM_allfunction(GameCommand), "QC function GameCommand is missing"); prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize; } @@ -1137,7 +1156,7 @@ 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]; @@ -1180,7 +1199,7 @@ fail: 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]; @@ -1229,7 +1248,7 @@ 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(cmd) != 5) { @@ -1243,7 +1262,7 @@ static void PRVM_ED_EdictSet_f(cmd_state_t *cmd) ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(cmd, 2))); if((key = PRVM_ED_FindField(prog, Cmd_Argv(cmd, 3))) == 0) - Con_Printf("Key %s not found !\n", Cmd_Argv(cmd, 3)); + Con_Printf("Key %s not found!\n", Cmd_Argv(cmd, 3)); else PRVM_ED_ParseEpair(prog, ed, key, Cmd_Argv(cmd, 4), true); } @@ -1259,9 +1278,9 @@ Used for initial level load and for savegames. */ 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; @@ -1282,7 +1301,7 @@ const char *PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_ // and allow them to be turned into vectors. (FIXME...) if (!strcmp(com_token, "angle")) { - strlcpy (com_token, "angles", sizeof(com_token)); + dp_strlcpy (com_token, "angles", sizeof(com_token)); anglehack = true; } else @@ -1290,9 +1309,9 @@ const char *PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_ // FIXME: change light to _light to get rid of this hack if (!strcmp(com_token, "light")) - strlcpy (com_token, "light_lev", sizeof(com_token)); // hack for single light def + dp_strlcpy (com_token, "light_lev", sizeof(com_token)); // hack for single light def - strlcpy (keyname, com_token, sizeof(keyname)); + dp_strlcpy (keyname, com_token, sizeof(keyname)); // another hack to fix keynames with trailing spaces n = strlen(keyname); @@ -1332,7 +1351,7 @@ const char *PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_ if (anglehack) { char temp[32]; - strlcpy (temp, com_token, sizeof(temp)); + dp_strlcpy (temp, com_token, sizeof(temp)); dpsnprintf (com_token, sizeof(com_token), "0 %s 0", temp); } @@ -1341,13 +1360,119 @@ const char *PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_ } if (!init) { - ent->priv.required->free = true; - ent->priv.required->freetime = host.realtime; + 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"); + } +} /* ================ @@ -1369,11 +1494,6 @@ void PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data) prvm_edict_t *ent; const char *start; int parsed, inhibited, spawned, died; - ddef_t *fulldata_ddef = NULL; - prvm_eval_t *fulldata = NULL; - const char *funcname; - mfunction_t *func; - char vabuf[1024]; parsed = 0; inhibited = 0; @@ -1382,10 +1502,12 @@ void PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data) 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] != '{') @@ -1403,7 +1525,7 @@ void PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data) // clear it if (ent != prog->edicts) // hack memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t)); - start = data; + data = PRVM_ED_ParseEdict (prog, data, ent); parsed++; @@ -1415,107 +1537,23 @@ void PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data) 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; - } - /* - * 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 - { - fulldata_ddef = PRVM_ED_FindGlobal(prog, "__fullspawndata"); - if(fulldata_ddef) - fulldata = (prvm_eval_t *) &prog->globals.fp[fulldata_ddef->ofs]; - if(fulldata) - { - 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); + 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++; } @@ -1702,7 +1740,7 @@ static void PRVM_PO_ParseString(char *out, const char *in, size_t outsize) 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') @@ -1819,7 +1857,8 @@ static po_t *PRVM_PO_Load(const char *filename, const char *filename2, mempool_t break; if((size_t)(q - p) >= (size_t) sizeof(inbuf)) break; - strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL + memcpy(inbuf, p, q - p - 1); + inbuf[q - p - 1] = '\0'; PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos); decodedpos += strlen(decodedbuf + decodedpos); if(*q == '\r') @@ -1846,7 +1885,7 @@ static po_t *PRVM_PO_Load(const char *filename, const char *filename2, mempool_t memset(&thisstr, 0, sizeof(thisstr)); } } - + Mem_Free((char *) buf); } @@ -1914,7 +1953,7 @@ static void PRVM_LoadLNO( prvm_prog_t *prog, const char *progname ) { char filename[512]; FS_StripExtension( progname, filename, sizeof( filename ) ); - strlcat( filename, ".lno", sizeof( filename ) ); + dp_strlcat( filename, ".lno", sizeof( filename ) ); lno = FS_LoadFile( filename, tempmempool, false, &filesize ); if( !lno ) { @@ -1937,12 +1976,12 @@ static void PRVM_LoadLNO( prvm_prog_t *prog, const char *progname ) { } header = (unsigned int *) lno; - if( header[ 0 ] == *(unsigned int *) "LNOF" && - LittleLong( header[ 1 ] ) == 1 && - (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs_numglobaldefs && - (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs_numglobals && - (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs_numfielddefs && - (unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs_numstatements ) + if (memcmp(lno, "LNOF", 4) == 0 + && LittleLong( header[ 1 ] ) == 1 + && (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs_numglobaldefs + && (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs_numglobals + && (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs_numfielddefs + && (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, header + 6, prog->progs_numstatements * sizeof( int ) ); @@ -1959,17 +1998,22 @@ static void PRVM_LoadLNO( prvm_prog_t *prog, const char *progname ) { /* =============== -PRVM_LoadProgs +PRVM_Prog_Load =============== */ 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) +void PRVM_Prog_Load(prvm_prog_t *prog, const char *filename, unsigned char *data, fs_offset_t size, void CheckRequiredFuncs(prvm_prog_t *prog, const char *filename), 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; + + 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; @@ -1989,9 +2033,10 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da 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 ); + prog->error_cmd("%s: there is already a %s program loaded!", __func__, prog->name); Host_LockSession(); // all progs can use the session cvar Crypto_LoadKeys(); // all progs might use the keys at init time @@ -2004,14 +2049,12 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da 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); + prog->error_cmd("%s: couldn't load \"%s\" for %s", __func__, 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 = host.realtime; - Con_DPrintf("%s programs occupy %iK.\n", prog->name, (int)(filesize/1024)); - requiredglobalspace = 0; for (i = 0;i < numrequiredglobals;i++) requiredglobalspace += required_global[i].type == ev_vector ? 3 : 1; @@ -2021,13 +2064,29 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da // 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); @@ -2059,12 +2118,12 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da 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->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 = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numfielddefs + numrequiredfields) * sizeof(ddef_t)); + 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 @@ -2083,17 +2142,31 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da prog->functions[i].locals = LittleLong(infunctions[i].locals); memcpy(prog->functions[i].parm_size, infunctions[i].parm_size, sizeof(infunctions[i].parm_size)); if(prog->functions[i].first_statement >= prog->numstatements) - prog->error_cmd("PRVM_LoadProgs: out of bounds function statement (function %d) in %s", i, prog->name); + prog->error_cmd("%s: out of bounds function statement (function %d) in %s", __func__, i, prog->name); // TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size } // copy the globaldefs to the new globaldefs list - for (i=0 ; inumglobaldefs ; 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 ; inumglobaldefs ; 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 ; inumglobaldefs ; 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 @@ -2110,14 +2183,30 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da } // 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("%s: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", __func__, 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("%s: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", __func__, 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 @@ -2160,21 +2249,31 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da } } - // LadyHavoc: 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: case OP_IFNOT: b = (short)b; if (a >= prog->progs_numglobals || b + i < 0 || b + i >= prog->progs_numstatements) - prog->error_cmd("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s", i, prog->name); + prog->error_cmd("%s: out of bounds IF/IFNOT (statement %d) in %s", __func__, i, prog->name); prog->statements[i].op = op; prog->statements[i].operand[0] = remapglobal(a); prog->statements[i].operand[1] = -1; @@ -2184,7 +2283,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_GOTO: a = (short)a; if (a + i < 0 || a + i >= prog->progs_numstatements) - prog->error_cmd("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s", i, prog->name); + prog->error_cmd("%s: out of bounds GOTO (statement %d) in %s", __func__, i, prog->name); prog->statements[i].op = op; prog->statements[i].operand[0] = -1; prog->statements[i].operand[1] = -1; @@ -2192,8 +2291,83 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da prog->statements[i].jumpabsolute = i + a; break; default: - Con_DPrintf("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", (int)op, i, prog->name); + Con_DPrintf("%s: unknown opcode %d at statement %d in %s\n", __func__, (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: @@ -2230,7 +2404,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_LOAD_FNC: case OP_LOAD_V: if (a >= prog->progs_numglobals || b >= prog->progs_numglobals || c >= prog->progs_numglobals) - prog->error_cmd("PRVM_LoadProgs: out of bounds global index (statement %d)", i); + prog->error_cmd("%s: out of bounds global index (statement %d)", __func__, i); prog->statements[i].op = op; prog->statements[i].operand[0] = remapglobal(a); prog->statements[i].operand[1] = remapglobal(b); @@ -2244,7 +2418,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_NOT_FNC: case OP_NOT_ENT: if (a >= prog->progs_numglobals || c >= prog->progs_numglobals) - prog->error_cmd("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, prog->name); + prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name); prog->statements[i].op = op; prog->statements[i].operand[0] = remapglobal(a); prog->statements[i].operand[1] = -1; @@ -2257,6 +2431,9 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da 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("%s: storep-with-offset is not permitted in %s\n", __func__, prog->name); + //fallthrough case OP_STORE_F: case OP_STORE_ENT: case OP_STORE_FLD: @@ -2266,7 +2443,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_STOREP_V: case OP_STORE_V: if (a >= prog->progs_numglobals || b >= prog->progs_numglobals) - prog->error_cmd("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, prog->name); + prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name); prog->statements[i].op = op; prog->statements[i].operand[0] = remapglobal(a); prog->statements[i].operand[1] = remapglobal(b); @@ -2291,7 +2468,9 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_DONE: 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); + prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name); + if (b || c) //Spike -- added this check just as a diagnostic... + Con_DPrintf("%s: unexpected offset on call opcode in %s. Hexen2 format is not supported\n", __func__, prog->name); prog->statements[i].op = op; prog->statements[i].operand[0] = remapglobal(a); prog->statements[i].operand[1] = -1; @@ -2302,7 +2481,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da } if(prog->numstatements < 1) { - prog->error_cmd("PRVM_LoadProgs: empty program in %s", prog->name); + prog->error_cmd("%s: empty program in %s", __func__, prog->name); } else switch(prog->statements[prog->numstatements - 1].op) { @@ -2311,7 +2490,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da case OP_DONE: break; default: - prog->error_cmd("PRVM_LoadProgs: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", prog->name); + prog->error_cmd("%s: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", __func__, prog->name); break; } @@ -2320,10 +2499,9 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da Mem_Free(dprograms); dprograms = NULL; - // check required functions - for(i=0 ; i < numrequiredfunc ; i++) - if(PRVM_ED_FindFunction(prog, required_func[i]) == 0) - prog->error_cmd("%s: %s not found in %s",prog->name, required_func[i], filename); + prog->flag = 0; + // expected to not return (call prog->error_cmd) if checks fail + CheckRequiredFuncs(prog, filename); PRVM_LoadLNO(prog, filename); @@ -2333,7 +2511,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da // 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! { @@ -2419,14 +2597,14 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da { prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs); 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); + //Con_Printf("%s: autocvar global %s in %s, processing...\n", __func__, name, prog->name); if(!cvar) { const char *value; 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); + Con_DPrintf("%s: no cvar for autocvar global %s in %s, creating...\n", __func__, name, prog->name); switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) { case ev_float: @@ -2465,7 +2643,7 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da value = PRVM_GetString(prog, val->string); break; default: - Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, prog->name); + Con_Printf("%s: invalid type of autocvar global %s in %s\n", __func__, name, prog->name); goto fail; } cvar = Cvar_Get(prog->console_cmd->cvars, name + 9, value, prog->console_cmd->cvars_flagsmask, NULL); @@ -2475,10 +2653,10 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da cvar->globaldefindex_stringno[prog - prvm_prog_list] = val->string; } if(!cvar) - prog->error_cmd("PRVM_LoadProgs: could not create cvar for autocvar global %s in %s", name, prog->name); + prog->error_cmd("%s: could not create cvar for autocvar global %s in %s", __func__, name, prog->name); 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; @@ -2509,13 +2687,13 @@ void PRVM_Prog_Load(prvm_prog_t *prog, const char * filename, unsigned char * da cvar->globaldefindex_stringno[prog - prvm_prog_list] = val->string; break; default: - Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, prog->name); + Con_Printf("%s: invalid type of autocvar global %s in %s\n", __func__, name, prog->name); goto fail; } cvar->globaldefindex[prog - prvm_prog_list] = i; } else - Con_Printf("PRVM_LoadProgs: private cvar for autocvar global %s in %s\n", name, prog->name); + Con_Printf("%s: private cvar for autocvar global %s in %s\n", __func__, name, prog->name); } fail: ; @@ -2525,9 +2703,7 @@ fail: PRVM_UpdateBreakpoints(prog); - // set flags & ddef_ts in prog - - prog->flag = 0; + // set flags & mdef_ts in prog PRVM_FindOffsets(prog); @@ -2536,6 +2712,9 @@ fail: // init mempools PRVM_MEM_Alloc(prog); + Con_Printf("%s: program loaded (crc %i, size %iK)%s\n", prog->name, prog->filecrc, (int)(filesize/1024), + prog == CLVM_prog ? (prog->flag & PRVM_CSQC_SIMPLE ? " CSQC_SIMPLE" : " EXT_CSQC") : ""); + // Inittime is at least the time when this function finished. However, // later events may bump it. prog->inittime = host.realtime; @@ -2550,7 +2729,7 @@ static void PRVM_Fields_f(cmd_state_t *cmd) char tempstring[MAX_INPUTLINE], tempstring2[260]; const char *name; prvm_edict_t *ed; - ddef_t *d; + mdef_t *d; prvm_eval_t *val; // TODO @@ -2575,7 +2754,7 @@ static void PRVM_Fields_f(cmd_state_t *cmd) 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++) { @@ -2607,32 +2786,32 @@ static void PRVM_Fields_f(cmd_state_t *cmd) switch(d->type & ~DEF_SAVEGLOBAL) { case ev_string: - strlcat(tempstring, "string ", sizeof(tempstring)); + dp_strlcat(tempstring, "string ", sizeof(tempstring)); break; case ev_entity: - strlcat(tempstring, "entity ", sizeof(tempstring)); + dp_strlcat(tempstring, "entity ", sizeof(tempstring)); break; case ev_function: - strlcat(tempstring, "function ", sizeof(tempstring)); + dp_strlcat(tempstring, "function ", sizeof(tempstring)); break; case ev_field: - strlcat(tempstring, "field ", sizeof(tempstring)); + dp_strlcat(tempstring, "field ", sizeof(tempstring)); break; case ev_void: - strlcat(tempstring, "void ", sizeof(tempstring)); + dp_strlcat(tempstring, "void ", sizeof(tempstring)); break; case ev_float: - strlcat(tempstring, "float ", sizeof(tempstring)); + dp_strlcat(tempstring, "float ", sizeof(tempstring)); break; case ev_vector: - strlcat(tempstring, "vector ", sizeof(tempstring)); + dp_strlcat(tempstring, "vector ", sizeof(tempstring)); break; case ev_pointer: - strlcat(tempstring, "pointer ", sizeof(tempstring)); + dp_strlcat(tempstring, "pointer ", sizeof(tempstring)); break; default: dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL); - strlcat(tempstring, tempstring2, sizeof(tempstring)); + dp_strlcat(tempstring, tempstring2, sizeof(tempstring)); break; } if (strlen(name) > sizeof(tempstring2)-4) @@ -2642,12 +2821,12 @@ static void PRVM_Fields_f(cmd_state_t *cmd) tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strlcat(tempstring, name, sizeof(tempstring)); + dp_strlcat(tempstring, name, sizeof(tempstring)); for (j = (int)strlen(name);j < 25;j++) - strlcat(tempstring, " ", sizeof(tempstring)); + dp_strlcat(tempstring, " ", sizeof(tempstring)); dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]); - strlcat(tempstring, tempstring2, sizeof(tempstring)); - strlcat(tempstring, "\n", sizeof(tempstring)); + dp_strlcat(tempstring, tempstring2, sizeof(tempstring)); + dp_strlcat(tempstring, "\n", sizeof(tempstring)); if (strlen(tempstring) >= sizeof(tempstring)/2) { Con_Print(tempstring); @@ -2713,7 +2892,7 @@ PRVM_Global 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(cmd) != 3 ) { Con_Printf( "prvm_global \n" ); @@ -2738,7 +2917,7 @@ PRVM_GlobalSet static void PRVM_GlobalSet_f(cmd_state_t *cmd) { prvm_prog_t *prog; - ddef_t *global; + mdef_t *global; if( Cmd_Argc(cmd) != 4 ) { Con_Printf( "prvm_globalset \n" ); return; @@ -2829,7 +3008,7 @@ static void PRVM_UpdateBreakpoints(prvm_prog_t *prog) if (debug->watch_global[0]) { - ddef_t *global = PRVM_ED_FindGlobal( prog, debug->watch_global ); + 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 ); @@ -2850,7 +3029,7 @@ static void PRVM_UpdateBreakpoints(prvm_prog_t *prog) if (debug->watch_field[0]) { - ddef_t *field = PRVM_ED_FindField( prog, debug->watch_field ); + 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 ); @@ -2898,7 +3077,7 @@ static void PRVM_Breakpoint_f(cmd_state_t *cmd) { debug_data_t *debug = &debug_data[prog - prvm_prog_list]; - strlcpy(debug->break_statement, Cmd_Argv(cmd, 2), sizeof(debug->break_statement)); + dp_strlcpy(debug->break_statement, Cmd_Argv(cmd, 2), sizeof(debug->break_statement)); } PRVM_UpdateBreakpoints(prog); } @@ -2927,7 +3106,7 @@ static void PRVM_GlobalWatchpoint_f(cmd_state_t *cmd) { debug_data_t *debug = &debug_data[prog - prvm_prog_list]; - strlcpy(debug->watch_global, Cmd_Argv(cmd, 2), sizeof(debug->watch_global)); + dp_strlcpy(debug->watch_global, Cmd_Argv(cmd, 2), sizeof(debug->watch_global)); } PRVM_UpdateBreakpoints(prog); } @@ -2957,7 +3136,7 @@ static void PRVM_EdictWatchpoint_f(cmd_state_t *cmd) { 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)); + dp_strlcpy(debug->watch_field, Cmd_Argv(cmd, 3), sizeof(debug->watch_field)); } PRVM_UpdateBreakpoints(prog); } @@ -2969,26 +3148,28 @@ PRVM_Init */ void PRVM_Init (void) { - Cmd_AddCommand(CMD_SHARED, "prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_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(CMD_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(CMD_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(CMD_SHARED, "prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_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(CMD_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(CMD_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(CMD_SHARED, "prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)"); - Cmd_AddCommand(CMD_SHARED, "cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument"); - Cmd_AddCommand(CMD_SHARED, "menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument"); - Cmd_AddCommand(CMD_SHARED, "sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument"); - Cmd_AddCommand(CMD_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(CMD_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(CMD_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"); + 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); @@ -3010,9 +3191,21 @@ void PRVM_Init (void) 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 } /* @@ -3176,27 +3369,27 @@ int PRVM_SetEngineString(prvm_prog_t *prog, const char *s) // restores it on return, so multiple recursive calls can share the same // buffer) // the buffer size is automatically grown as needed - -int PRVM_SetTempString(prvm_prog_t *prog, const char *s) +int PRVM_SetTempString(prvm_prog_t *prog, const char *s, size_t slen) { - int size; + size_t size; char *t; - if (!s) + + if (!s || slen >= VM_TEMPSTRING_MAXSIZE) return 0; - size = (int)strlen(s) + 1; + size = slen + 1; if (developer_insane.integer) - Con_DPrintf("PRVM_SetTempString: cursize %i, size %i\n", prog->tempstringsbuf.cursize, size); - if (prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size) + Con_DPrintf("PRVM_SetTempString %s: cursize %i, new tempstring size %lu\n", prog->name, prog->tempstringsbuf.cursize, (unsigned long)size); + if ((size_t)prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size) { sizebuf_t old = prog->tempstringsbuf; if (prog->tempstringsbuf.cursize + size >= 1<<28) - prog->error_cmd("PRVM_SetTempString: ran out of tempstring memory! (refusing to grow tempstring buffer over 256MB, cursize %i, size %i)\n", prog->tempstringsbuf.cursize, size); + prog->error_cmd("PRVM_SetTempString %s: ran out of tempstring memory! (refusing to grow tempstring buffer over 256MB, cursize %i, new tempstring size %lu)\n", prog->name, prog->tempstringsbuf.cursize, (unsigned long)size); prog->tempstringsbuf.maxsize = max(prog->tempstringsbuf.maxsize, 65536); - while (prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size) + while ((size_t)prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size) prog->tempstringsbuf.maxsize *= 2; if (prog->tempstringsbuf.maxsize != old.maxsize || prog->tempstringsbuf.data == NULL) { - Con_DPrintf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, prog->tempstringsbuf.maxsize/1024); + Con_DPrintf("PRVM_SetTempString %s: enlarging tempstrings buffer (%iKB -> %iKB)\n", prog->name, old.maxsize/1024, prog->tempstringsbuf.maxsize/1024); prog->tempstringsbuf.data = (unsigned char *) Mem_Alloc(prog->progs_mempool, prog->tempstringsbuf.maxsize); if (old.data) { @@ -3237,16 +3430,16 @@ int PRVM_AllocString(prvm_prog_t *prog, size_t bufferlength, char **pointer) void PRVM_FreeString(prvm_prog_t *prog, int num) { if (num == 0) - prog->error_cmd("PRVM_FreeString: attempt to free a NULL string"); + prog->error_cmd("PRVM_FreeString %s: attempt to free a NULL string", prog->name); else if (num >= 0 && num < prog->stringssize) - prog->error_cmd("PRVM_FreeString: attempt to free a constant string"); + prog->error_cmd("PRVM_FreeString %s: attempt to free a constant string", prog->name); else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings) { num = num - PRVM_KNOWNSTRINGBASE; if (!prog->knownstrings[num]) - prog->error_cmd("PRVM_FreeString: attempt to free a non-existent or already freed string"); + prog->error_cmd("PRVM_FreeString %s: attempt to free a non-existent or already freed string", prog->name); if (!prog->knownstrings_flags[num]) - prog->error_cmd("PRVM_FreeString: attempt to free a string owned by the engine"); + prog->error_cmd("PRVM_FreeString %s: attempt to free a string owned by the engine", prog->name); PRVM_Free((char *)prog->knownstrings[num]); if(prog->leaktest_active) if(prog->knownstrings_origin[num]) @@ -3256,16 +3449,16 @@ void PRVM_FreeString(prvm_prog_t *prog, int num) prog->firstfreeknownstring = min(prog->firstfreeknownstring, num); } else - prog->error_cmd("PRVM_FreeString: invalid string offset %i", num); + prog->error_cmd("PRVM_FreeString %s: invalid string offset %i", prog->name, 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)) @@ -3275,11 +3468,11 @@ static qboolean PRVM_IsStringReferenced(prvm_prog_t *prog, string_t string) 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; inumfielddefs; ++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)) @@ -3290,13 +3483,13 @@ static qboolean PRVM_IsStringReferenced(prvm_prog_t *prog, string_t string) 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->priv.required->freetime <= prog->inittime) + if (edict->freetime <= prog->inittime) return true; // created during startup if (prog == SVVM_prog) { @@ -3342,7 +3535,7 @@ static qboolean PRVM_IsEdictRelevant(prvm_prog_t *prog, prvm_edict_t *edict) 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); @@ -3371,7 +3564,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_prog_t *prog, prvm_edict_t *edict, i } for (i=0; inumfielddefs; ++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)) @@ -3385,7 +3578,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_prog_t *prog, prvm_edict_t *edict, i static void PRVM_MarkReferencedEdicts(prvm_prog_t *prog) { int i, j; - qboolean found_new; + qbool found_new; int stage; // Stage 1: world, all entities that are relevant, and all entities that are referenced by globals. @@ -3393,13 +3586,13 @@ static void PRVM_MarkReferencedEdicts(prvm_prog_t *prog) 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++) { - ddef_t *d = &prog->globaldefs[i]; + mdef_t *d = &prog->globaldefs[i]; prvm_edict_t *ed; if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity) continue; @@ -3419,7 +3612,7 @@ static void PRVM_MarkReferencedEdicts(prvm_prog_t *prog) 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; @@ -3438,7 +3631,7 @@ static void PRVM_MarkReferencedEdicts(prvm_prog_t *prog) void PRVM_LeakTest(prvm_prog_t *prog) { int i, j; - qboolean leaked = false; + qbool leaked = false; if(!prog->leaktest_active) return; @@ -3461,7 +3654,7 @@ void PRVM_LeakTest(prvm_prog_t *prog) 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) @@ -3512,7 +3705,7 @@ void PRVM_LeakTest(prvm_prog_t *prog) void PRVM_GarbageCollection(prvm_prog_t *prog) { - int limit = prvm_garbagecollection_scan_limit.integer; + int limit = prvm_garbagecollection_scan_limit.integer * (prog == SVVM_prog ? sv.frametime : cl.realframetime); prvm_prog_garbagecollection_state_t *gc = &prog->gc; if (!prvm_garbagecollection_enable.integer) return; @@ -3529,7 +3722,7 @@ void PRVM_GarbageCollection(prvm_prog_t *prog) case PRVM_GC_GLOBALS_MARK: for (; gc->globals_mark_progress < prog->numglobaldefs && (limit--) > 0; gc->globals_mark_progress++) { - ddef_t *d = &prog->globaldefs[gc->globals_mark_progress]; + mdef_t *d = &prog->globaldefs[gc->globals_mark_progress]; switch (d->type) { case ev_string: @@ -3559,7 +3752,7 @@ void PRVM_GarbageCollection(prvm_prog_t *prog) case PRVM_GC_FIELDS_MARK: for (; gc->fields_mark_progress < prog->numfielddefs && limit > 0;) { - ddef_t *d = &prog->fielddefs[gc->fields_mark_progress]; + mdef_t *d = &prog->fielddefs[gc->fields_mark_progress]; switch (d->type) { case ev_string: @@ -3631,5 +3824,6 @@ void PRVM_GarbageCollection(prvm_prog_t *prog) case PRVM_GC_RESET: default: memset(gc, 0, sizeof(*gc)); +// Con_Printf("%s%s GC: reset @ %f frametime %f scan_limit per frame %i\n", prog == SVVM_prog ? "^6" : "^5", prog->name, host.realtime, prog == SVVM_prog ? sv.frametime : cl.realframetime, limit); } }