X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=b3cd3f0539772f2aef0cf4a8567a6dbc90f85110;hp=5aa1d6af158f12d58511922791f5eb2dde98431d;hb=016c63753d2811583fa86cfcee0a58cb7c57392b;hpb=449b12475e1848290002970f45fd4bdcd0a4d462 diff --git a/prvm_edict.c b/prvm_edict.c index 5aa1d6af..56a1e3f4 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -17,9 +17,10 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -// AK new vm +// AK new vm #include "quakedef.h" +#include "progsvm.h" prvm_prog_t *prog; @@ -28,15 +29,24 @@ static prvm_prog_t prog_list[PRVM_MAXPROGS]; int prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4}; ddef_t *PRVM_ED_FieldAtOfs(int ofs); -qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s); +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)) -cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1"}; +cvar_t prvm_language = {0, "prvm_language", "", "when set, loads progs.dat.LANGUAGENAME.po for string translations; when set to dump, progs.dat.dump.po is written from the strings in the progs"}; // LordHavoc: prints every opcode as it executes - warning: this is significant spew -cvar_t prvm_traceqc = {0, "prvm_traceqc", "0"}; +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", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"}; +cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"}; +cvar_t prvm_reuseedicts_startuptime = {0, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"}; +cvar_t prvm_reuseedicts_neverinsameframe = {0, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"}; -ddef_t *PRVM_ED_FindField (const char *name); -mfunction_t *PRVM_ED_FindFunction (const char *name); +static double prvm_reuseedicts_always_allow = 0; +qboolean prvm_runawaycheck = true; + +extern sizebuf_t vm_tempstringsbuf; //============================================================================ // mempool handling @@ -46,32 +56,33 @@ mfunction_t *PRVM_ED_FindFunction (const char *name); PRVM_MEM_Alloc =============== */ -void PRVM_MEM_Alloc() +void PRVM_MEM_Alloc(void) { int i; // reserve space for the null entity aka world // check bound of max_edicts - prog->max_edicts = bound(1, prog->max_edicts, prog->limit_edicts); - prog->num_edicts = bound(1, prog->num_edicts, prog->max_edicts); + prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts); + prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts); // edictprivate_size has to be min as big prvm_edict_private_t - prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t)); + prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t)); // alloc edicts - prog->edicts = Mem_Alloc(prog->edicts_mempool,prog->limit_edicts * sizeof(prvm_edict_t)); - + prog->edicts = (prvm_edict_t *)Mem_Alloc(prog->progs_mempool,prog->limit_edicts * sizeof(prvm_edict_t)); + // alloc edict private space - prog->edictprivate = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edictprivate_size); - + prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size); + // alloc edict fields - prog->edictsfields = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edict_size); + prog->entityfieldsarea = prog->entityfields * prog->max_edicts; + prog->edictsfields = (vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(vec_t)); // set edict pointers for(i = 0; i < prog->max_edicts; i++) { - prog->edicts[i].e = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); - prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); + prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char *)prog->edictprivate + i * prog->edictprivate_size); + prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields; } } @@ -80,38 +91,30 @@ void PRVM_MEM_Alloc() PRVM_MEM_IncreaseEdicts =============== */ -void PRVM_MEM_IncreaseEdicts() +void PRVM_MEM_IncreaseEdicts(void) { int i; - int oldmaxedicts = prog->max_edicts; - void *oldedictsfields = prog->edictsfields; - void *oldedictprivate = prog->edictprivate; - + if(prog->max_edicts >= prog->limit_edicts) return; - + PRVM_GCALL(begin_increase_edicts)(); // increase edicts prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts); - prog->edictsfields = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edict_size); - prog->edictprivate = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edictprivate_size); - - memcpy(prog->edictsfields, oldedictsfields, oldmaxedicts * prog->edict_size); - memcpy(prog->edictprivate, oldedictprivate, oldmaxedicts * prog->edictprivate_size); + prog->entityfieldsarea = prog->entityfields * prog->max_edicts; + prog->edictsfields = (vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields, prog->entityfieldsarea * sizeof(vec_t)); + prog->edictprivate = (void *)Mem_Realloc(prog->progs_mempool, (void *)prog->edictprivate, prog->max_edicts * prog->edictprivate_size); //set e and v pointers for(i = 0; i < prog->max_edicts; i++) { - prog->edicts[i].e = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); - prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); + prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char *)prog->edictprivate + i * prog->edictprivate_size); + prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields; } PRVM_GCALL(end_increase_edicts)(); - - Mem_Free(oldedictsfields); - Mem_Free(oldedictprivate); } //============================================================================ @@ -122,8 +125,26 @@ int PRVM_ED_FindFieldOffset(const char *field) ddef_t *d; d = PRVM_ED_FindField(field); if (!d) + return -1; + return d->ofs; +} + +int PRVM_ED_FindGlobalOffset(const char *global) +{ + ddef_t *d; + d = PRVM_ED_FindGlobal(global); + if (!d) + return -1; + return d->ofs; +} + +func_t PRVM_ED_FindFunctionOffset(const char *function) +{ + mfunction_t *f; + f = PRVM_ED_FindFunction(function); + if (!f) return 0; - return d->ofs*4; + return (func_t)(f - prog->functions); } qboolean PRVM_ProgLoaded(int prognr) @@ -169,15 +190,15 @@ PRVM_SetProg */ void PRVM_SetProg(int prognr) { - if(prognr && prognr < PRVM_MAXPROGS) - { + if(0 <= prognr && prognr < PRVM_MAXPROGS) + { if(prog_list[prognr].loaded) prog = &prog_list[prognr]; else - PRVM_ERROR("%i(%s) not loaded !\n", prognr, PRVM_NAME); + PRVM_ERROR("%i not loaded !", prognr); return; } - PRVM_ERROR("Invalid program number %i\n", prognr); + PRVM_ERROR("Invalid program number %i", prognr); } /* @@ -189,14 +210,45 @@ Sets everything to NULL */ void PRVM_ED_ClearEdict (prvm_edict_t *e) { - int num; - memset (e->v, 0, prog->progs->entityfields * 4); - e->e->free = false; - // LordHavoc: for consistency set these here - num = PRVM_NUM_FOR_EDICT(e) - 1; + memset (e->fields.vp, 0, prog->progs->entityfields * 4); + e->priv.required->free = false; // AK: Let the init_edict function determine if something needs to be initialized - PRVM_GCALL(init_edict)(num); + PRVM_GCALL(init_edict)(e); +} + +const char *PRVM_AllocationOrigin(void) +{ + char *buf = NULL; + if(prog->leaktest_active) + if(prog->depth > 0) // actually in QC code and not just parsing the entities block of a map/savegame + { + buf = (char *)PRVM_Alloc(128); + PRVM_ShortStackTrace(buf, 128); + } + return buf; +} + +/* +================= +PRVM_ED_CanAlloc + +Returns if this particular edict could get allocated by PRVM_ED_Alloc +================= +*/ +qboolean PRVM_ED_CanAlloc(prvm_edict_t *e) +{ + if(!e->priv.required->free) + return false; + if(prvm_reuseedicts_always_allow == realtime) + return true; + if(realtime <= e->priv.required->freetime && 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) + return true; + if(realtime > e->priv.required->freetime + 1) + return true; + return false; // entity slot still blocked because the entity was freed less than one second ago } /* @@ -220,19 +272,18 @@ prvm_edict_t *PRVM_ED_Alloc (void) // AK: changed i=svs.maxclients+1 // AK: changed so the edict 0 wont spawn -> used as reserved/world entity // although the menu/client has no world - for (i = 1;i < prog->num_edicts;i++) + for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++) { e = PRVM_EDICT_NUM(i); - // the first couple seconds of server time can involve a lot of - // freeing and allocating, so relax the replacement policy - if (e->e->free && ( e->e->freetime < 2 || (*prog->time - e->e->freetime) > 0.5 ) ) + if(PRVM_ED_CanAlloc(e)) { PRVM_ED_ClearEdict (e); + e->priv.required->allocation_origin = PRVM_AllocationOrigin(); return e; } } - if (i == MAX_EDICTS) + if (i == prog->limit_edicts) PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME); prog->num_edicts++; @@ -242,6 +293,8 @@ prvm_edict_t *PRVM_ED_Alloc (void) e = PRVM_EDICT_NUM(i); PRVM_ED_ClearEdict (e); + e->priv.required->allocation_origin = PRVM_AllocationOrigin(); + return e; } @@ -255,14 +308,19 @@ FIXME: walk all entities and NULL out references to this entity */ void PRVM_ED_Free (prvm_edict_t *ed) { - // dont delete the null entity (world) - if(PRVM_NUM_FOR_EDICT(ed) == 0) + // dont delete the null entity (world) or reserved edicts + if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) return; PRVM_GCALL(free_edict)(ed); - ed->e->free = true; - ed->e->freetime = *prog->time; + ed->priv.required->free = true; + ed->priv.required->freetime = realtime; + if(ed->priv.required->allocation_origin) + { + PRVM_Free((char *)ed->priv.required->allocation_origin); + ed->priv.required->allocation_origin = NULL; + } } //=========================================================================== @@ -373,49 +431,49 @@ Returns a string describing *data in a type specific manner */ char *PRVM_ValueString (etype_t type, prvm_eval_t *val) { - static char line[1024]; // LordHavoc: enlarged a bit (was 256) + static char line[MAX_INPUTLINE]; ddef_t *def; mfunction_t *f; int n; - type &= ~DEF_SAVEGLOBAL; + type = (etype_t)((int) type & ~DEF_SAVEGLOBAL); switch (type) { case ev_string: - sprintf (line, "%s", PRVM_GetString(val->string)); + strlcpy (line, PRVM_GetString (val->string), sizeof (line)); break; case ev_entity: n = val->edict; - if (n < 0 || n >= MAX_EDICTS) - sprintf (line, "entity %i (invalid!)", n); + if (n < 0 || n >= prog->max_edicts) + dpsnprintf (line, sizeof(line), "entity %i (invalid!)", n); else - sprintf (line, "entity %i", n); + dpsnprintf (line, sizeof(line), "entity %i", n); break; case ev_function: f = prog->functions + val->function; - sprintf (line, "%s()", PRVM_GetString(f->s_name)); + dpsnprintf (line, sizeof(line), "%s()", PRVM_GetString(f->s_name)); break; case ev_field: def = PRVM_ED_FieldAtOfs ( val->_int ); - sprintf (line, ".%s", PRVM_GetString(def->s_name)); + dpsnprintf (line, sizeof(line), ".%s", PRVM_GetString(def->s_name)); break; case ev_void: - sprintf (line, "void"); + dpsnprintf (line, sizeof(line), "void"); break; case ev_float: // LordHavoc: changed from %5.1f to %10.4f - sprintf (line, "%10.4f", val->_float); + dpsnprintf (line, sizeof(line), "%10.4f", val->_float); break; case ev_vector: // LordHavoc: changed from %5.1f to %10.4f - sprintf (line, "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]); + dpsnprintf (line, sizeof(line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]); break; case ev_pointer: - sprintf (line, "pointer"); + dpsnprintf (line, sizeof(line), "pointer"); break; default: - sprintf (line, "bad type %i", type); + dpsnprintf (line, sizeof(line), "bad type %i", (int) type); break; } @@ -432,14 +490,14 @@ Easier to parse than PR_ValueString */ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val) { - static char line[4096]; + static char line[MAX_INPUTLINE]; int i; - char *s; + const char *s; ddef_t *def; mfunction_t *f; - - type &= ~DEF_SAVEGLOBAL; - + + type = (etype_t)((int)type & ~DEF_SAVEGLOBAL); + switch (type) { case ev_string: @@ -459,6 +517,16 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val) line[i++] = '\\'; line[i++] = 'r'; } + else if (*s == '\\') + { + line[i++] = '\\'; + line[i++] = '\\'; + } + else if (*s == '"') + { + line[i++] = '\\'; + line[i++] = '"'; + } else line[i++] = *s; s++; @@ -466,30 +534,30 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val) line[i] = '\0'; break; case ev_entity: - snprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict))); + dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict))); break; case ev_function: - f = pr_functions + val->function; - snprintf (line, sizeof (line), "%s", PRVM_GetString(f->s_name)); + f = prog->functions + val->function; + strlcpy (line, PRVM_GetString (f->s_name), sizeof (line)); break; case ev_field: def = PRVM_ED_FieldAtOfs ( val->_int ); - snprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name)); + dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name)); break; case ev_void: - snprintf (line, sizeof (line), "void"); + dpsnprintf (line, sizeof (line), "void"); break; case ev_float: - snprintf (line, sizeof (line), "%f", val->_float); + dpsnprintf (line, sizeof (line), "%.9g", val->_float); break; case ev_vector: - snprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); + dpsnprintf (line, sizeof (line), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]); break; default: - snprintf (line, sizeof (line), "bad type %i", type); + dpsnprintf (line, sizeof (line), "bad type %i", type); break; } - + return line; } @@ -504,45 +572,45 @@ padded to 20 field width char *PRVM_GlobalString (int ofs) { char *s; - int i; + //size_t i; ddef_t *def; void *val; static char line[128]; - val = (void *)&prog->globals[ofs]; + val = (void *)&prog->globals.generic[ofs]; def = PRVM_ED_GlobalAtOfs(ofs); if (!def) - sprintf (line,"%i(?)", ofs); + dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs); else { - s = PRVM_ValueString (def->type, val); - sprintf (line,"%i(%s)%s", ofs, PRVM_GetString(def->s_name), s); + s = PRVM_ValueString ((etype_t)def->type, (prvm_eval_t *)val); + dpsnprintf (line, sizeof(line), "%s (=%s)", PRVM_GetString(def->s_name), s); } - i = strlen(line); - for ( ; i<20 ; i++) - strcat (line," "); - strcat (line," "); + //i = strlen(line); + //for ( ; i<20 ; i++) + // strcat (line," "); + //strcat (line," "); return line; } char *PRVM_GlobalStringNoContents (int ofs) { - int i; + //size_t i; ddef_t *def; static char line[128]; def = PRVM_ED_GlobalAtOfs(ofs); if (!def) - sprintf (line,"%i(?)", ofs); + dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs); else - sprintf (line,"%i(%s)", ofs, PRVM_GetString(def->s_name)); + dpsnprintf (line, sizeof(line), "%s", PRVM_GetString(def->s_name)); - i = strlen(line); - for ( ; i<20 ; i++) - strcat (line," "); - strcat (line," "); + //i = strlen(line); + //for ( ; i<20 ; i++) + // strcat (line," "); + //strcat (line," "); return line; } @@ -557,24 +625,24 @@ For debugging */ // LordHavoc: optimized this to print out much more quickly (tempstring) // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print) -void PRVM_ED_Print (prvm_edict_t *ed) +void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname) { - int l; + size_t l; ddef_t *d; int *v; int i, j; - char *name; + const char *name; int type; - char tempstring[8192], tempstring2[260]; // temporary string buffers + char tempstring[MAX_INPUTLINE], tempstring2[260]; // temporary string buffers - if (ed->e->free) + if (ed->priv.required->free) { - Con_Printf ("%s: FREE\n",PRVM_NAME); + Con_Printf("%s: FREE\n",PRVM_NAME); return; } tempstring[0] = 0; - sprintf(tempstring, "\n%s EDICT %i:\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ed)); + dpsnprintf(tempstring, sizeof(tempstring), "\n%s EDICT %i:\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ed)); for (i=1 ; iprogs->numfielddefs ; i++) { d = &prog->fielddefs[i]; @@ -582,7 +650,13 @@ void PRVM_ED_Print (prvm_edict_t *ed) if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - v = (int *)((char *)ed->v + d->ofs*4); + // Check Field Name Wildcard + if(wildcard_fieldname) + if( !matchpattern(name, wildcard_fieldname, 1) ) + // Didn't match; skip + continue; + + v = (int *)(ed->fields.vp + d->ofs); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; @@ -593,36 +667,36 @@ void PRVM_ED_Print (prvm_edict_t *ed) if (j == prvm_type_size[type]) continue; - if (strlen(name) > 256) + if (strlen(name) > sizeof(tempstring2)-4) { - strncpy(tempstring2, name, 256); - tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; - tempstring2[259] = 0; + memcpy (tempstring2, name, sizeof(tempstring2)-4); + tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.'; + tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); + strlcat(tempstring, name, sizeof(tempstring)); for (l = strlen(name);l < 14;l++) - strcat(tempstring, " "); - strcat(tempstring, " "); + strlcat(tempstring, " ", sizeof(tempstring)); + strlcat(tempstring, " ", sizeof(tempstring)); - name = PRVM_ValueString(d->type, (prvm_eval_t *)v); - if (strlen(name) > 256) + name = PRVM_ValueString((etype_t)d->type, (prvm_eval_t *)v); + if (strlen(name) > sizeof(tempstring2)-4) { - strncpy(tempstring2, name, 256); - tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; - tempstring2[259] = 0; + memcpy (tempstring2, name, sizeof(tempstring2)-4); + tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.'; + tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); - strcat(tempstring, "\n"); - if (strlen(tempstring) >= 4096) + strlcat(tempstring, name, sizeof(tempstring)); + strlcat(tempstring, "\n", sizeof(tempstring)); + if (strlen(tempstring) >= sizeof(tempstring)/2) { - Con_Printf("%s", tempstring); + Con_Print(tempstring); tempstring[0] = 0; } } if (tempstring[0]) - Con_Printf("%s", tempstring); + Con_Print(tempstring); } /* @@ -632,19 +706,20 @@ PRVM_ED_Write For savegames ============= */ +extern cvar_t developer_entityparsing; void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) { ddef_t *d; int *v; int i, j; - char *name; + const char *name; int type; - FS_Printf (f, "{\n"); + FS_Print(f, "{\n"); - if (ed->e->free) + if (ed->priv.required->free) { - FS_Printf (f, "}\n"); + FS_Print(f, "}\n"); return; } @@ -652,10 +727,14 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) { 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 - v = (int *)((char *)ed->v + d->ofs*4); + v = (int *)(ed->fields.vp + d->ofs); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; @@ -665,16 +744,18 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) if (j == prvm_type_size[type]) continue; - FS_Printf (f,"\"%s\" ",name); - FS_Printf (f,"\"%s\"\n", PRVM_UglyValueString(d->type, (prvm_eval_t *)v)); + 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_Printf (f, "}\n"); + FS_Print(f, "}\n"); } -void PRVM_ED_PrintNum (int ent) +void PRVM_ED_PrintNum (int ent, const char *wildcard_fieldname) { - PRVM_ED_Print (PRVM_EDICT_NUM(ent)); + PRVM_ED_Print(PRVM_EDICT_NUM(ent), wildcard_fieldname); } /* @@ -687,20 +768,26 @@ For debugging, prints all the entities in the current server void PRVM_ED_PrintEdicts_f (void) { int i; + const char *wildcard_fieldname; - if(Cmd_Argc() != 2) + if(Cmd_Argc() < 2 || Cmd_Argc() > 3) { - Con_Printf("prvm_edicts \n"); + Con_Print("prvm_edicts \n"); return; } - + PRVM_Begin; if(!PRVM_SetProgFromString(Cmd_Argv(1))) return; - Con_Printf ("%s: %i entities\n", PRVM_NAME, prog->num_edicts); + if( Cmd_Argc() == 3) + wildcard_fieldname = Cmd_Argv(2); + else + wildcard_fieldname = NULL; + + Con_Printf("%s: %i entities\n", PRVM_NAME, prog->num_edicts); for (i=0 ; inum_edicts ; i++) - PRVM_ED_PrintNum (i); + PRVM_ED_PrintNum (i, wildcard_fieldname); PRVM_End; } @@ -715,10 +802,11 @@ For debugging, prints a single edict void PRVM_ED_PrintEdict_f (void) { int i; + const char *wildcard_fieldname; - if(Cmd_Argc() != 3) + if(Cmd_Argc() < 3 || Cmd_Argc() > 4) { - Con_Printf("prvm_edict \n"); + Con_Print("prvm_edict \n"); return; } @@ -729,11 +817,17 @@ void PRVM_ED_PrintEdict_f (void) i = atoi (Cmd_Argv(2)); if (i >= prog->num_edicts) { - Con_Printf("Bad edict number\n"); + Con_Print("Bad edict number\n"); PRVM_End; return; } - PRVM_ED_PrintNum (i); + if( Cmd_Argc() == 4) + // Optional Wildcard Provided + wildcard_fieldname = Cmd_Argv(3); + else + // Use All + wildcard_fieldname = NULL; + PRVM_ED_PrintNum (i, wildcard_fieldname); PRVM_End; } @@ -755,7 +849,7 @@ void PRVM_ED_Count_f (void) if(Cmd_Argc() != 2) { - Con_Printf("prvm_count \n"); + Con_Print("prvm_count \n"); return; } @@ -771,13 +865,13 @@ void PRVM_ED_Count_f (void) for (i=0 ; inum_edicts ; i++) { ent = PRVM_EDICT_NUM(i); - if (ent->e->free) + if (ent->priv.required->free) continue; active++; } - - Con_Printf ("num_edicts:%3i\n", prog->num_edicts); - Con_Printf ("active :%3i\n", active); + + Con_Printf("num_edicts:%3i\n", prog->num_edicts); + Con_Printf("active :%3i\n", active); } PRVM_End; @@ -801,10 +895,10 @@ void PRVM_ED_WriteGlobals (qfile_t *f) { ddef_t *def; int i; - char *name; + const char *name; int type; - FS_Printf (f,"{\n"); + FS_Print(f,"{\n"); for (i=0 ; iprogs->numglobaldefs ; i++) { def = &prog->globaldefs[i]; @@ -817,10 +911,16 @@ void PRVM_ED_WriteGlobals (qfile_t *f) continue; name = PRVM_GetString(def->s_name); - FS_Printf (f,"\"%s\" ", name); - FS_Printf (f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals[def->ofs])); + + 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_Printf (f,"}\n"); + FS_Print(f,"}\n"); } /* @@ -830,34 +930,40 @@ PRVM_ED_ParseGlobals */ void PRVM_ED_ParseGlobals (const char *data) { - char keyname[1024]; // LordHavoc: good idea? bad idea? was 64 + char keyname[MAX_INPUTLINE]; ddef_t *key; while (1) { // parse key - if (!COM_ParseToken(&data, false)) - PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace"); + if (!COM_ParseToken_Simple(&data, false, false)) + PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace"); if (com_token[0] == '}') break; - strcpy (keyname, com_token); + if (developer_entityparsing.integer) + Con_Printf("Key: \"%s\"", com_token); + + strlcpy (keyname, com_token, sizeof(keyname)); // parse value - if (!COM_ParseToken(&data, false)) - PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace"); + 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_ParseEntity: closing brace without data"); + PRVM_ERROR ("PRVM_ED_ParseGlobals: closing brace without data"); key = PRVM_ED_FindGlobal (keyname); if (!key) { - Con_DPrintf ("'%s' is not a global on %s\n", keyname, PRVM_NAME); + Con_DPrintf("'%s' is not a global on %s\n", keyname, PRVM_NAME); continue; } - if (!PRVM_ED_ParseEpair(NULL, key, com_token)) + if (!PRVM_ED_ParseEpair(NULL, key, com_token, true)) PRVM_ERROR ("PRVM_ED_ParseGlobals: parse error"); } } @@ -865,38 +971,6 @@ void PRVM_ED_ParseGlobals (const char *data) //============================================================================ -/* -============= -PRVM_ED_NewString -============= -*/ -char *PRVM_ED_NewString (const char *string) -{ - char *new, *new_p; - int i,l; - - l = strlen(string) + 1; - new = Mem_Alloc(prog->edictstring_mempool, l); - new_p = new; - - for (i=0 ; i< l ; i++) - { - if (string[i] == '\\' && i < l-1) - { - i++; - if (string[i] == 'n') - *new_p++ = '\n'; - else - *new_p++ = '\\'; - } - else - *new_p++ = string[i]; - } - - return new; -} - - /* ============= PRVM_ED_ParseEval @@ -905,25 +979,42 @@ Can parse either fields or globals returns false if error ============= */ -qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) +qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash) { - int i; + int i, l; + char *new_p; ddef_t *def; prvm_eval_t *val; mfunction_t *func; if (ent) - val = (prvm_eval_t *)((int *)ent->v + key->ofs); + val = (prvm_eval_t *)(ent->fields.vp + key->ofs); else - val = (prvm_eval_t *)((int *)pr_globals + key->ofs); + val = (prvm_eval_t *)(prog->globals.generic + key->ofs); switch (key->type & ~DEF_SAVEGLOBAL) { case ev_string: - val->string = PRVM_SetString(PRVM_ED_NewString(s)); + l = (int)strlen(s) + 1; + val->string = PRVM_AllocString(l, &new_p); + for (i = 0;i < l;i++) + { + if (s[i] == '\\' && s[i+1] && parsebackslash) + { + i++; + if (s[i] == 'n') + *new_p++ = '\n'; + else if (s[i] == 'r') + *new_p++ = '\r'; + else + *new_p++ = s[i]; + } + else + *new_p++ = s[i]; + } break; case ev_float: - while (*s && *s <= ' ') + while (*s && ISWHITESPACE(*s)) s++; val->_float = atof(s); break; @@ -931,12 +1022,12 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) 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; @@ -944,47 +1035,250 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) break; case ev_entity: - while (*s && *s <= ' ') + while (*s && ISWHITESPACE(*s)) s++; i = atoi(s); - if (i < 0 || i >= MAX_EDICTS) - Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME); + if (i >= prog->limit_edicts) + Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, prog->limit_edicts, PRVM_NAME); while (i >= prog->max_edicts) PRVM_MEM_IncreaseEdicts(); - //SV_IncreaseEdicts(); - // if SV_IncreaseEdicts was called the base pointer needs to be updated + // if IncreaseEdicts was called the base pointer needs to be updated if (ent) - val = (prvm_eval_t *)((int *)ent->v + key->ofs); - val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i)); + val = (prvm_eval_t *)(ent->fields.vp + key->ofs); + val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i)); break; case ev_field: - def = PRVM_ED_FindField(s); + if (*s != '.') + { + Con_DPrintf("PRVM_ED_ParseEpair: Bogus field name %s in %s\n", s, PRVM_NAME); + return false; + } + def = PRVM_ED_FindField(s + 1); if (!def) { Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s in %s\n", s, PRVM_NAME); return false; } - val->_int = PRVM_G_INT(def->ofs); + val->_int = def->ofs; break; case ev_function: func = PRVM_ED_FindFunction(s); if (!func) { - Con_Printf ("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, PRVM_NAME); + Con_Printf("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, PRVM_NAME); return false; } val->function = func - prog->functions; break; default: - Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PR_GetString(key->s_name), PRVM_NAME); + Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME); return false; } return true; } +/* +============= +PRVM_GameCommand_f + +Console command to send a string to QC function GameCommand of the +indicated progs + +Usage: + sv_cmd adminmsg 3 "do not teamkill" + cl_cmd someclientcommand + menu_cmd somemenucommand + +All progs can support this extension; sg calls it in server QC, cg in client +QC, mg in menu QC. +============= +*/ +void PRVM_GameCommand(const char *whichprogs, const char *whichcmd) +{ + if(Cmd_Argc() < 1) + { + Con_Printf("%s text...\n", whichcmd); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(whichprogs)) + // note: this is not PRVM_SetProg because that one aborts "hard" using PRVM_Error + // also, it makes printing error messages easier! + { + Con_Printf("%s program not loaded.\n", whichprogs); + return; + } + + if(!prog->funcoffsets.GameCommand) + { + Con_Printf("%s program do not support GameCommand!\n", whichprogs); + } + else + { + int restorevm_tempstringsbuf_cursize; + const char *s; + + s = Cmd_Args(); + + restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize; + PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(s ? s : ""); + PRVM_ExecuteProgram (prog->funcoffsets.GameCommand, "QC function GameCommand is missing"); + vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize; + } + + PRVM_End; +} +void PRVM_GameCommand_Server_f(void) +{ + PRVM_GameCommand("server", "sv_cmd"); +} +void PRVM_GameCommand_Client_f(void) +{ + PRVM_GameCommand("client", "cl_cmd"); +} +void PRVM_GameCommand_Menu_f(void) +{ + PRVM_GameCommand("menu", "menu_cmd"); +} + +/* +============= +PRVM_ED_EdictGet_f + +Console command to load a field of a specified edict +============= +*/ +void PRVM_ED_EdictGet_f(void) +{ + prvm_edict_t *ed; + ddef_t *key; + const char *s; + prvm_eval_t *v; + + if(Cmd_Argc() != 4 && Cmd_Argc() != 5) + { + Con_Print("prvm_edictget []\n"); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(Cmd_Argv(1))) + { + Con_Printf("Wrong program name %s !\n", Cmd_Argv(1)); + return; + } + + ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2))); + + if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0) + { + Con_Printf("Key %s not found !\n", Cmd_Argv(3)); + goto fail; + } + + v = (prvm_eval_t *)(ed->fields.vp + key->ofs); + s = PRVM_UglyValueString(key->type, v); + if(Cmd_Argc() == 5) + { + cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4)); + if (cvar && cvar->flags & CVAR_READONLY) + { + Con_Printf("prvm_edictget: %s is read-only\n", cvar->name); + goto fail; + } + Cvar_Get(Cmd_Argv(4), s, 0, NULL); + } + else + Con_Printf("%s\n", s); + +fail: + PRVM_End; +} + +void PRVM_ED_GlobalGet_f(void) +{ + ddef_t *key; + const char *s; + prvm_eval_t *v; + + if(Cmd_Argc() != 3 && Cmd_Argc() != 4) + { + Con_Print("prvm_globalget []\n"); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(Cmd_Argv(1))) + { + Con_Printf("Wrong program name %s !\n", Cmd_Argv(1)); + return; + } + + key = PRVM_ED_FindGlobal(Cmd_Argv(2)); + if(!key) + { + Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) ); + goto fail; + } + + v = (prvm_eval_t *) &prog->globals.generic[key->ofs]; + s = PRVM_UglyValueString(key->type, v); + if(Cmd_Argc() == 4) + { + cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3)); + if (cvar && cvar->flags & CVAR_READONLY) + { + Con_Printf("prvm_globalget: %s is read-only\n", cvar->name); + goto fail; + } + Cvar_Get(Cmd_Argv(3), s, 0, NULL); + } + else + Con_Printf("%s\n", s); + +fail: + PRVM_End; +} + +/* +============= +PRVM_ED_EdictSet_f + +Console command to set a field of a specified edict +============= +*/ +void PRVM_ED_EdictSet_f(void) +{ + prvm_edict_t *ed; + ddef_t *key; + + if(Cmd_Argc() != 5) + { + Con_Print("prvm_edictset \n"); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(Cmd_Argv(1))) + { + Con_Printf("Wrong program name %s !\n", Cmd_Argv(1)); + return; + } + + ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2))); + + if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0) + Con_Printf("Key %s not found !\n", Cmd_Argv(3)); + else + PRVM_ED_ParseEpair(ed, key, Cmd_Argv(4), true); + + PRVM_End; +} + /* ==================== PRVM_ED_ParseEdict @@ -1000,20 +1294,18 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) qboolean anglehack; qboolean init; char keyname[256]; - int n; + size_t n; init = false; -// clear it - if (ent != prog->edicts) // hack - memset (ent->v, 0, prog->progs->entityfields * 4); - // go through all the dictionary pairs while (1) { // parse key - if (!COM_ParseToken(&data, false)) - PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace"); + if (!COM_ParseToken_Simple(&data, false, false)) + PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace"); + if (developer_entityparsing.integer) + Con_Printf("Key: \"%s\"", com_token); if (com_token[0] == '}') break; @@ -1021,7 +1313,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) // and allow them to be turned into vectors. (FIXME...) if (!strcmp(com_token, "angle")) { - strcpy (com_token, "angles"); + strlcpy (com_token, "angles", sizeof(com_token)); anglehack = true; } else @@ -1029,9 +1321,9 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) // FIXME: change light to _light to get rid of this hack if (!strcmp(com_token, "light")) - strcpy (com_token, "light_lev"); // hack for single light def + strlcpy (com_token, "light_lev", sizeof(com_token)); // hack for single light def - strcpy (keyname, com_token); + strlcpy (keyname, com_token, sizeof(keyname)); // another hack to fix keynames with trailing spaces n = strlen(keyname); @@ -1042,14 +1334,20 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) } // parse value - if (!COM_ParseToken(&data, false)) - PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace"); + if (!COM_ParseToken_Simple(&data, false, false)) + PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace"); + if (developer_entityparsing.integer) + Con_Printf(" \"%s\"\n", com_token); if (com_token[0] == '}') - PRVM_ERROR ("PRVM_ED_ParseEntity: closing brace without data"); + PRVM_ERROR ("PRVM_ED_ParseEdict: closing brace without data"); init = true; + // ignore attempts to set key "" (this problem occurs in nehahra neh1m8.bsp) + if (!keyname[0]) + continue; + // keynames with a leading underscore are used for utility comments, // and are immediately discarded by quake if (keyname[0] == '_') @@ -1058,23 +1356,23 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) key = PRVM_ED_FindField (keyname); if (!key) { - Con_DPrintf ("%s: '%s' is not a field\n", PRVM_NAME, keyname); + Con_DPrintf("%s: '%s' is not a field\n", PRVM_NAME, keyname); continue; } if (anglehack) { char temp[32]; - strcpy (temp, com_token); - sprintf (com_token, "0 %s 0", temp); + strlcpy (temp, com_token, sizeof(temp)); + dpsnprintf (com_token, sizeof(com_token), "0 %s 0", temp); } - if (!PRVM_ED_ParseEpair(ent, key, com_token)) + if (!PRVM_ED_ParseEpair(ent, key, com_token, strcmp(keyname, "wad") != 0)) PRVM_ERROR ("PRVM_ED_ParseEdict: parse error"); } if (!init) - ent->e->free = true; + ent->priv.required->free = true; return data; } @@ -1099,6 +1397,7 @@ void PRVM_ED_LoadFromFile (const char *data) { prvm_edict_t *ent; int parsed, inhibited, spawned, died; + const char *funcname; mfunction_t *func; parsed = 0; @@ -1106,22 +1405,30 @@ void PRVM_ED_LoadFromFile (const char *data) spawned = 0; died = 0; + prvm_reuseedicts_always_allow = realtime; // parse ents while (1) { // parse the opening brace - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, false)) break; if (com_token[0] != '{') PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token); - // CHANGED: this is not conform to ED_LoadFromFile - if(!prog->num_edicts) + // CHANGED: this is not conform to PR_LoadFromFile + if(prog->loadintoworld) + { + prog->loadintoworld = false; ent = PRVM_EDICT_NUM(0); - else + } + else ent = PRVM_ED_Alloc(); + // clear it + if (ent != prog->edicts) // hack + memset (ent->fields.vp, 0, prog->progs->entityfields * 4); + data = PRVM_ED_ParseEdict (data, ent); parsed++; @@ -1133,46 +1440,300 @@ void PRVM_ED_LoadFromFile (const char *data) 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 +// immediately call spawn function, but only if there is a self global and a classname // - if(prog->self && prog->flag & PRVM_FE_CLASSNAME) + if(!ent->priv.required->free) + if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0) { - string_t handle = *(string_t*)&((float*)ent->v)[PRVM_ED_FindFieldOffset("classname")]; + string_t handle = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string; if (!handle) { - Con_Printf ("No classname for:\n"); - PRVM_ED_Print (ent); + Con_Print("No classname for:\n"); + PRVM_ED_Print(ent, NULL); PRVM_ED_Free (ent); continue; } - + // look for the spawn function - func = PRVM_ED_FindFunction (PRVM_GetString(handle)); - + funcname = PRVM_GetString(handle); + func = PRVM_ED_FindFunction (va("spawnfunc_%s", funcname)); + if(!func) + if(prog->globaloffsets.require_spawnfunc_prefix < 0) + func = PRVM_ED_FindFunction (funcname); + if (!func) { - if (developer.integer) // don't confuse non-developers with errors + // check for OnEntityNoSpawnFunction + if (prog->funcoffsets.SV_OnEntityNoSpawnFunction) { - Con_Printf ("No spawn function for:\n"); - PRVM_ED_Print (ent); + // self = ent + PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent); + PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing"); } - PRVM_ED_Free (ent); - continue; + else + { + if (developer.integer > 0) // don't confuse non-developers with errors + { + Con_Print("No spawn function for:\n"); + PRVM_ED_Print(ent, NULL); + } + PRVM_ED_Free (ent); + continue; // not included in "inhibited" count + } + } + else + { + // self = ent + PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent); + PRVM_ExecuteProgram (func - prog->functions, ""); } - + } + + if(!ent->priv.required->free) + if (prog->funcoffsets.SV_OnEntityPostSpawnFunction) + { // self = ent - PRVM_G_INT(prog->self->ofs) = PRVM_EDICT_TO_PROG(ent); - PRVM_ExecuteProgram (func - prog->functions, ""); + 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->e->free) + if (ent->priv.required->free) died++; } - Con_DPrintf ("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died); -} + Con_DPrintf("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died); + + prvm_reuseedicts_always_allow = 0; +} + +void PRVM_FindOffsets(void) +{ + // field and global searches use -1 for NULL + memset(&prog->fieldoffsets, -1, sizeof(prog->fieldoffsets)); + memset(&prog->globaloffsets, -1, sizeof(prog->globaloffsets)); + // functions use 0 for NULL + memset(&prog->funcoffsets, 0, sizeof(prog->funcoffsets)); + + // 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.ammo_lava_nails = PRVM_ED_FindFieldOffset("ammo_lava_nails"); + prog->fieldoffsets.ammo_multi_rockets = PRVM_ED_FindFieldOffset("ammo_multi_rockets"); + prog->fieldoffsets.ammo_nails1 = PRVM_ED_FindFieldOffset("ammo_nails1"); + prog->fieldoffsets.ammo_plasma = PRVM_ED_FindFieldOffset("ammo_plasma"); + prog->fieldoffsets.ammo_rockets1 = PRVM_ED_FindFieldOffset("ammo_rockets1"); + prog->fieldoffsets.ammo_shells1 = PRVM_ED_FindFieldOffset("ammo_shells1"); + prog->fieldoffsets.angles = PRVM_ED_FindFieldOffset("angles"); + prog->fieldoffsets.button3 = PRVM_ED_FindFieldOffset("button3"); + prog->fieldoffsets.button4 = PRVM_ED_FindFieldOffset("button4"); + prog->fieldoffsets.button5 = PRVM_ED_FindFieldOffset("button5"); + prog->fieldoffsets.button6 = PRVM_ED_FindFieldOffset("button6"); + prog->fieldoffsets.button7 = PRVM_ED_FindFieldOffset("button7"); + prog->fieldoffsets.button8 = PRVM_ED_FindFieldOffset("button8"); + prog->fieldoffsets.button9 = PRVM_ED_FindFieldOffset("button9"); + prog->fieldoffsets.button10 = PRVM_ED_FindFieldOffset("button10"); + prog->fieldoffsets.button11 = PRVM_ED_FindFieldOffset("button11"); + prog->fieldoffsets.button12 = PRVM_ED_FindFieldOffset("button12"); + prog->fieldoffsets.button13 = PRVM_ED_FindFieldOffset("button13"); + prog->fieldoffsets.button14 = PRVM_ED_FindFieldOffset("button14"); + prog->fieldoffsets.button15 = PRVM_ED_FindFieldOffset("button15"); + prog->fieldoffsets.button16 = PRVM_ED_FindFieldOffset("button16"); + prog->fieldoffsets.buttonchat = PRVM_ED_FindFieldOffset("buttonchat"); + 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.cursor_active = PRVM_ED_FindFieldOffset("cursor_active"); + prog->fieldoffsets.cursor_screen = PRVM_ED_FindFieldOffset("cursor_screen"); + prog->fieldoffsets.cursor_trace_endpos = PRVM_ED_FindFieldOffset("cursor_trace_endpos"); + prog->fieldoffsets.cursor_trace_ent = PRVM_ED_FindFieldOffset("cursor_trace_ent"); + prog->fieldoffsets.cursor_trace_start = PRVM_ED_FindFieldOffset("cursor_trace_start"); + prog->fieldoffsets.customizeentityforclient = PRVM_ED_FindFieldOffset("customizeentityforclient"); + prog->fieldoffsets.dimension_hit = PRVM_ED_FindFieldOffset("dimension_hit"); + prog->fieldoffsets.dimension_solid = PRVM_ED_FindFieldOffset("dimension_solid"); + prog->fieldoffsets.disableclientprediction = PRVM_ED_FindFieldOffset("disableclientprediction"); + prog->fieldoffsets.dphitcontentsmask = PRVM_ED_FindFieldOffset("dphitcontentsmask"); + prog->fieldoffsets.drawonlytoclient = PRVM_ED_FindFieldOffset("drawonlytoclient"); + prog->fieldoffsets.exteriormodeltoclient = PRVM_ED_FindFieldOffset("exteriormodeltoclient"); + prog->fieldoffsets.fatness = PRVM_ED_FindFieldOffset("fatness"); + prog->fieldoffsets.forceshader = PRVM_ED_FindFieldOffset("forceshader"); + prog->fieldoffsets.frame = PRVM_ED_FindFieldOffset("frame"); + 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.glow_trail = PRVM_ED_FindFieldOffset("glow_trail"); + prog->fieldoffsets.glowmod = PRVM_ED_FindFieldOffset("glowmod"); + prog->fieldoffsets.gravity = PRVM_ED_FindFieldOffset("gravity"); + prog->fieldoffsets.groundentity = PRVM_ED_FindFieldOffset("groundentity"); + prog->fieldoffsets.hull = PRVM_ED_FindFieldOffset("hull"); + prog->fieldoffsets.ideal_yaw = PRVM_ED_FindFieldOffset("ideal_yaw"); + 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.movement = PRVM_ED_FindFieldOffset("movement"); + prog->fieldoffsets.movetypesteplandevent = PRVM_ED_FindFieldOffset("movetypesteplandevent"); + prog->fieldoffsets.netaddress = PRVM_ED_FindFieldOffset("netaddress"); + prog->fieldoffsets.nextthink = PRVM_ED_FindFieldOffset("nextthink"); + prog->fieldoffsets.nodrawtoclient = PRVM_ED_FindFieldOffset("nodrawtoclient"); + prog->fieldoffsets.pflags = PRVM_ED_FindFieldOffset("pflags"); + prog->fieldoffsets.ping = PRVM_ED_FindFieldOffset("ping"); + prog->fieldoffsets.packetloss = PRVM_ED_FindFieldOffset("ping_packetloss"); + prog->fieldoffsets.movementloss = PRVM_ED_FindFieldOffset("ping_movementloss"); + prog->fieldoffsets.pitch_speed = PRVM_ED_FindFieldOffset("pitch_speed"); + prog->fieldoffsets.playermodel = PRVM_ED_FindFieldOffset("playermodel"); + prog->fieldoffsets.playerskin = PRVM_ED_FindFieldOffset("playerskin"); + prog->fieldoffsets.pmodel = PRVM_ED_FindFieldOffset("pmodel"); + prog->fieldoffsets.punchvector = PRVM_ED_FindFieldOffset("punchvector"); + prog->fieldoffsets.renderamt = PRVM_ED_FindFieldOffset("renderamt"); // HalfLife support + 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.skeletonindex = PRVM_ED_FindFieldOffset("skeletonindex"); + 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.think = PRVM_ED_FindFieldOffset("think"); + 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.bouncefactor = PRVM_ED_FindFieldOffset("bouncefactor"); + prog->fieldoffsets.bouncestop = PRVM_ED_FindFieldOffset("bouncestop"); + + prog->fieldoffsets.solid = PRVM_ED_FindFieldOffset("solid"); + prog->fieldoffsets.movetype = PRVM_ED_FindFieldOffset("movetype"); + prog->fieldoffsets.modelindex = PRVM_ED_FindFieldOffset("modelindex"); + prog->fieldoffsets.mins = PRVM_ED_FindFieldOffset("mins"); + prog->fieldoffsets.maxs = PRVM_ED_FindFieldOffset("maxs"); + prog->fieldoffsets.mass = PRVM_ED_FindFieldOffset("mass"); + prog->fieldoffsets.origin = PRVM_ED_FindFieldOffset("origin"); + prog->fieldoffsets.velocity = PRVM_ED_FindFieldOffset("velocity"); + //prog->fieldoffsets.axis_forward = PRVM_ED_FindFieldOffset("axis_forward"); + //prog->fieldoffsets.axis_left = PRVM_ED_FindFieldOffset("axis_left"); + //prog->fieldoffsets.axis_up = PRVM_ED_FindFieldOffset("axis_up"); + //prog->fieldoffsets.spinvelocity = PRVM_ED_FindFieldOffset("spinvelocity"); + prog->fieldoffsets.angles = PRVM_ED_FindFieldOffset("angles"); + prog->fieldoffsets.avelocity = PRVM_ED_FindFieldOffset("avelocity"); + prog->fieldoffsets.aiment = PRVM_ED_FindFieldOffset("aiment"); + prog->fieldoffsets.enemy = PRVM_ED_FindFieldOffset("enemy"); + prog->fieldoffsets.jointtype = PRVM_ED_FindFieldOffset("jointtype"); + prog->fieldoffsets.movedir = PRVM_ED_FindFieldOffset("movedir"); + + prog->fieldoffsets.camera_transform = PRVM_ED_FindFieldOffset("camera_transform"); + + prog->funcoffsets.CSQC_ConsoleCommand = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand"); + prog->funcoffsets.CSQC_Ent_Remove = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove"); + 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_InputEvent = PRVM_ED_FindFunctionOffset("CSQC_InputEvent"); + prog->funcoffsets.CSQC_Parse_CenterPrint = PRVM_ED_FindFunctionOffset("CSQC_Parse_CenterPrint"); + prog->funcoffsets.CSQC_Parse_Print = PRVM_ED_FindFunctionOffset("CSQC_Parse_Print"); + prog->funcoffsets.CSQC_Parse_StuffCmd = PRVM_ED_FindFunctionOffset("CSQC_Parse_StuffCmd"); + 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.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_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.drawfontscale = PRVM_ED_FindGlobalOffset("drawfontscale"); + 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.transparent_offset = PRVM_ED_FindGlobalOffset("transparent_offset"); + 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.trace_allsolid = PRVM_ED_FindGlobalOffset("trace_allsolid"); + 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.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"); + prog->funcoffsets.m_init = PRVM_ED_FindFunctionOffset("m_init"); + prog->funcoffsets.m_keydown = PRVM_ED_FindFunctionOffset("m_keydown"); + prog->funcoffsets.m_keyup = PRVM_ED_FindFunctionOffset("m_keyup"); + prog->funcoffsets.m_shutdown = PRVM_ED_FindFunctionOffset("m_shutdown"); + prog->funcoffsets.m_toggle = PRVM_ED_FindFunctionOffset("m_toggle"); +} // not used /* @@ -1196,30 +1757,302 @@ PRVM_ResetProg =============== */ -void PRVM_ResetProg() +#define PO_HASHSIZE 16384 +typedef struct po_string_s { - /*mempool_t *t1, *t2, *t3; - - t1 = prog->progs_mempool; - t2 = prog->edictstring_mempool; - t3 = prog->edicts_mempool; - - Mem_EmptyPool(prog->progs_mempool); - Mem_EmptyPool(prog->edictstring_mempool); - Mem_EmptyPool(prog->edicts_mempool);*/ - Mem_FreePool(&prog->progs_mempool); - Mem_FreePool(&prog->edictstring_mempool); - Mem_FreePool(&prog->edicts_mempool); - - memset(prog,0,sizeof(prvm_prog_t)); - - /*prog->time = &prog->_time; - - prog->progs_mempool = t1; - prog->edictstring_mempool = t2; - prog->edicts_mempool = t3;*/ - - PRVM_GCALL(reset_cmd)(); + char *key, *value; + struct po_string_s *nextonhashchain; +} +po_string_t; +typedef struct po_s +{ + po_string_t *hashtable[PO_HASHSIZE]; +} +po_t; +void PRVM_PO_UnparseString(char *out, const char *in, size_t outsize) +{ + for(;;) + { + switch(*in) + { + case 0: + *out++ = 0; + return; + case '\a': if(outsize >= 2) { *out++ = '\\'; *out++ = 'a'; outsize -= 2; } break; + case '\b': if(outsize >= 2) { *out++ = '\\'; *out++ = 'b'; outsize -= 2; } break; + case '\t': if(outsize >= 2) { *out++ = '\\'; *out++ = 't'; outsize -= 2; } break; + case '\r': if(outsize >= 2) { *out++ = '\\'; *out++ = 'r'; outsize -= 2; } break; + case '\n': if(outsize >= 2) { *out++ = '\\'; *out++ = 'n'; outsize -= 2; } break; + case '\\': if(outsize >= 2) { *out++ = '\\'; *out++ = '\\'; outsize -= 2; } break; + case '"': if(outsize >= 2) { *out++ = '\\'; *out++ = '"'; outsize -= 2; } break; + default: + if(*in >= 0 && *in <= 0x1F) + { + if(outsize >= 4) + { + *out++ = '\\'; + *out++ = '0' + ((*in & 0700) >> 6); + *out++ = '0' + ((*in & 0070) >> 3); + *out++ = '0' + ((*in & 0007)); + outsize -= 4; + } + } + else + { + if(outsize >= 1) + { + *out++ = *in; + outsize -= 1; + } + } + break; + } + ++in; + } +} +void PRVM_PO_ParseString(char *out, const char *in, size_t outsize) +{ + for(;;) + { + switch(*in) + { + case 0: + *out++ = 0; + return; + case '\\': + ++in; + switch(*in) + { + case 'a': if(outsize > 0) { *out++ = '\a'; --outsize; } break; + case 'b': if(outsize > 0) { *out++ = '\b'; --outsize; } break; + case 't': if(outsize > 0) { *out++ = '\t'; --outsize; } break; + case 'r': if(outsize > 0) { *out++ = '\r'; --outsize; } break; + case 'n': if(outsize > 0) { *out++ = '\n'; --outsize; } break; + 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) + *out = *in - '0'; + ++in; + if(*in >= '0' && *in <= '7') + { + if(outsize > 0) + *out = (*out << 3) | (*in - '0'); + ++in; + } + if(*in >= '0' && *in <= '7') + { + if(outsize > 0) + *out = (*out << 3) | (*in - '0'); + ++in; + } + --in; + if(outsize > 0) + { + ++out; + --outsize; + } + break; + default: + if(outsize > 0) { *out++ = *in; --outsize; } + break; + } + break; + default: + if(outsize > 0) + { + *out++ = *in; + --outsize; + } + break; + } + ++in; + } +} +po_t *PRVM_PO_Load(const char *filename, mempool_t *pool) +{ + po_t *po; + const char *p, *q; + int mode; + char inbuf[MAX_INPUTLINE]; + char decodedbuf[MAX_INPUTLINE]; + size_t decodedpos; + int hashindex; + po_string_t thisstr; + const char *buf = (const char *) FS_LoadFile(filename, pool, true, NULL); + + if(!buf) + return NULL; + + po = Mem_Alloc(pool, sizeof(*po)); + memset(po, 0, sizeof(*po)); + + p = buf; + while(*p) + { + if(*p == '#') + { + // skip to newline + p = strchr(p, '\n'); + if(!p) + break; + ++p; + continue; + } + if(*p == '\r' || *p == '\n') + { + ++p; + continue; + } + if(!strncmp(p, "msgid \"", 7)) + { + mode = 0; + p += 6; + } + else if(!strncmp(p, "msgstr \"", 8)) + { + mode = 1; + p += 7; + } + else + { + p = strchr(p, '\n'); + if(!p) + break; + ++p; + continue; + } + decodedpos = 0; + while(*p == '"') + { + ++p; + q = strchr(p, '\n'); + if(!q) + break; + if(*(q-1) == '\r') + --q; + if(*(q-1) != '"') + break; + if((size_t)(q - p) >= (size_t) sizeof(inbuf)) + break; + strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL + PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos); + decodedpos += strlen(decodedbuf + decodedpos); + if(*q == '\r') + ++q; + if(*q == '\n') + ++q; + p = q; + } + if(mode == 0) + { + if(thisstr.key) + Mem_Free(thisstr.key); + thisstr.key = Mem_Alloc(pool, decodedpos + 1); + memcpy(thisstr.key, decodedbuf, decodedpos + 1); + } + else if(decodedpos > 0 && thisstr.key) // skip empty translation results + { + thisstr.value = Mem_Alloc(pool, decodedpos + 1); + memcpy(thisstr.value, decodedbuf, decodedpos + 1); + hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE; + thisstr.nextonhashchain = po->hashtable[hashindex]; + po->hashtable[hashindex] = Mem_Alloc(pool, sizeof(thisstr)); + memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr)); + memset(&thisstr, 0, sizeof(thisstr)); + } + } + + Mem_Free((char *) buf); + return po; +} +const char *PRVM_PO_Lookup(po_t *po, const char *str) +{ + int hashindex = CRC_Block((const unsigned char *) str, strlen(str)) % PO_HASHSIZE; + po_string_t *p = po->hashtable[hashindex]; + while(p) + { + if(!strcmp(str, p->key)) + return p->value; + p = p->nextonhashchain; + } + return NULL; +} +void PRVM_PO_Destroy(po_t *po) +{ + int i; + for(i = 0; i < PO_HASHSIZE; ++i) + { + po_string_t *p = po->hashtable[i]; + while(p) + { + po_string_t *q = p; + p = p->nextonhashchain; + Mem_Free(q->key); + Mem_Free(q->value); + Mem_Free(q); + } + } + Mem_Free(po); +} + +void PRVM_LeakTest(void); +void PRVM_ResetProg(void) +{ + PRVM_LeakTest(); + PRVM_GCALL(reset_cmd)(); + Mem_FreePool(&prog->progs_mempool); + if(prog->po) + PRVM_PO_Destroy((po_t *) prog->po); + memset(prog,0,sizeof(prvm_prog_t)); + prog->starttime = Sys_DoubleTime(); +} + +/* +=============== +PRVM_LoadLNO +=============== +*/ +void PRVM_LoadLNO( const char *progname ) { + fs_offset_t filesize; + unsigned char *lno; + unsigned int *header; + char filename[512]; + + FS_StripExtension( progname, filename, sizeof( filename ) ); + strlcat( filename, ".lno", sizeof( filename ) ); + + lno = FS_LoadFile( filename, tempmempool, false, &filesize ); + if( !lno ) { + return; + } + +/* + SafeWrite (h, &lnotype, sizeof(int)); + SafeWrite (h, &version, sizeof(int)); + SafeWrite (h, &numglobaldefs, sizeof(int)); + SafeWrite (h, &numpr_globals, sizeof(int)); + SafeWrite (h, &numfielddefs, sizeof(int)); + SafeWrite (h, &numstatements, sizeof(int)); + SafeWrite (h, statement_linenums, numstatements*sizeof(int)); +*/ + if( (unsigned) filesize < (6 + prog->progs->numstatements) * sizeof( int ) ) { + Mem_Free(lno); + return; + } + + 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 ) + { + prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof( int ) ); + memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs->numstatements * sizeof( int ) ); + } + Mem_Free( lno ); } /* @@ -1227,29 +2060,26 @@ void PRVM_ResetProg() PRVM_LoadProgs =============== */ -void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func) +void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global) { int i; dstatement_t *st; ddef_t *infielddefs; - void *temp; dfunction_t *dfunctions; + fs_offset_t filesize; - Mem_EmptyPool(prog->progs_mempool); - Mem_EmptyPool(prog->edictstring_mempool); + if( prog->loaded ) { + PRVM_ERROR ("PRVM_LoadProgs: there is already a %s program loaded!", PRVM_NAME ); + } - temp = FS_LoadFile (filename, false); - if (temp == 0) + prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize); + if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t)) PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME); + // TODO bounds check header fields (e.g. numstatements), they must never go behind end of file - prog->progs = (dprograms_t *)Mem_Alloc(prog->progs_mempool, fs_filesize); + Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024)); - memcpy(prog->progs, temp, fs_filesize); - Mem_Free(temp); - - Con_DPrintf ("%s programs occupy %iK.\n", PRVM_NAME, fs_filesize/1024); - - pr_crc = CRC_Block((qbyte *)prog->progs, fs_filesize); + prog->filecrc = CRC_Block((unsigned char *)prog->progs, filesize); // byte swap the header for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++) @@ -1257,26 +2087,38 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required if (prog->progs->version != PROG_VERSION) PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION); - if (prog->progs->crc != prog->crc) - PRVM_ERROR ("%s: %s system vars have been modified, progdefs.h is out of date", PRVM_NAME, filename); + if (prog->progs->crc != prog->headercrc && prog->progs->crc != prog->headercrc2) + PRVM_ERROR ("%s: %s system vars have been modified (CRC of progs.dat systemvars %i != engine %i), progdefs.h is out of date", PRVM_NAME, filename, prog->progs->crc, prog->headercrc); + + //prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions); + dfunctions = (dfunction_t *)((unsigned char *)prog->progs + prog->progs->ofs_functions); - //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions); - dfunctions = (dfunction_t *)((qbyte *)prog->progs + prog->progs->ofs_functions); + if (prog->progs->ofs_strings + prog->progs->numstrings >= (int)filesize) + PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename); prog->strings = (char *)prog->progs + prog->progs->ofs_strings; - prog->globaldefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_globaldefs); + prog->stringssize = prog->progs->numstrings; + + prog->numknownstrings = 0; + prog->maxknownstrings = 0; + prog->knownstrings = NULL; + prog->knownstrings_freeable = NULL; + + Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64); + + prog->globaldefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_globaldefs); // we need to expand the fielddefs list to include all the engine fields, // so allocate a new place for it - infielddefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_fielddefs); + infielddefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_fielddefs); // ( + DPFIELDS ) - prog->fielddefs = Mem_Alloc(prog->progs_mempool, prog->progs->numfielddefs * sizeof(ddef_t)); + prog->fielddefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t)); - prog->statements = (dstatement_t *)((qbyte *)prog->progs + prog->progs->ofs_statements); + prog->statements = (dstatement_t *)((unsigned char *)prog->progs + prog->progs->ofs_statements); - // moved edict_size calculation down below field adding code + prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof(*prog->statement_profile)); - //pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals); - prog->globals = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals); + //pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals); + prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals); // byte swap the lumps for (i=0 ; iprogs->numstatements ; i++) @@ -1287,7 +2129,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->statements[i].c = LittleShort(prog->statements[i].c); } - prog->functions = Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions); + prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions); for (i = 0;i < prog->progs->numfunctions;i++) { prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement); @@ -1297,6 +2139,9 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->functions[i].numparms = LittleLong (dfunctions[i].numparms); prog->functions[i].locals = LittleLong (dfunctions[i].locals); memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size)); + if(prog->functions[i].first_statement >= prog->progs->numstatements) + PRVM_ERROR("PRVM_LoadProgs: out of bounds function statement (function %d) in %s", i, PRVM_NAME); + // TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size } for (i=0 ; iprogs->numglobaldefs ; i++) @@ -1304,6 +2149,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type); prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs); prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name); + // TODO bounds check ofs, s_name } // copy the progs fields to the new fields list @@ -1314,33 +2160,36 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_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 } -/* // append the darkplaces fields - for (i = 0;i < (int) DPFIELDS;i++) + // append the required fields + for (i = 0;i < (int) numrequiredfields;i++) { - pr_fielddefs[progs->numfielddefs].type = dpfields[i].type; - pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields; - pr_fielddefs[progs->numfielddefs].s_name = PR_SetString(dpfields[i].string); - if (pr_fielddefs[progs->numfielddefs].type == ev_vector) - progs->entityfields += 3; + prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type; + prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields; + prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name); + // TODO bounds check ofs, s_name + if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector) + prog->progs->entityfields += 3; else - progs->entityfields++; - progs->numfielddefs++; - }*/ + prog->progs->entityfields++; + prog->progs->numfielddefs++; + } + prog->entityfields = prog->progs->entityfields; // check required functions for(i=0 ; i < numrequiredfunc ; i++) if(PRVM_ED_FindFunction(required_func[i]) == 0) - PRVM_ERROR("%s: %s not found in %s\n",PRVM_NAME, required_func[i], filename); + PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_func[i], filename); - for (i=0 ; iprogs->numglobals ; i++) - ((int *)prog->globals)[i] = LittleLong (((int *)prog->globals)[i]); + // check required globals + for(i=0 ; i < numrequiredglobals ; i++) + if(PRVM_ED_FindGlobal(required_global[i]) == 0) + PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_global[i], filename); - // moved edict_size calculation down here, below field adding code - // LordHavoc: this no longer includes the edict_t header - prog->edict_size = prog->progs->entityfields * 4; - prog->edictareasize = prog->edict_size * MAX_EDICTS; + for (i=0 ; iprogs->numglobals ; i++) + ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]); // LordHavoc: bounds check anything static for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++) @@ -1350,11 +2199,11 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required case OP_IF: case OP_IFNOT: if ((unsigned short) st->a >= prog->progs->numglobals || st->b + i < 0 || st->b + i >= prog->progs->numstatements) - PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s\n", i, PRVM_NAME); + PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s", i, PRVM_NAME); break; case OP_GOTO: if (st->a + i < 0 || st->a + i >= prog->progs->numstatements) - PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s\n", i, PRVM_NAME); + PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s", i, PRVM_NAME); break; // global global global case OP_ADD_F: @@ -1392,7 +2241,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required case OP_LOAD_FNC: case OP_LOAD_V: if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals) - PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n", i); + PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)", i); break; // global none global case OP_NOT_F: @@ -1401,7 +2250,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required case OP_NOT_FNC: case OP_NOT_ENT: if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals) - PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME); + PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME); break; // 2 globals case OP_STOREP_F: @@ -1418,7 +2267,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required case OP_STOREP_V: case OP_STORE_V: if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals) - PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n in %s", i, PRVM_NAME); + PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME); break; // 1 global case OP_CALL0: @@ -1433,38 +2282,189 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required case OP_DONE: case OP_RETURN: if ((unsigned short) st->a >= prog->progs->numglobals) - PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME); + PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME); break; default: - PRVM_ERROR("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME); + Con_DPrintf("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME); break; } } + if(prog->progs->numstatements < 1) + { + PRVM_ERROR("PRVM_LoadProgs: empty program in %s", PRVM_NAME); + } + else switch(prog->statements[prog->progs->numstatements - 1].op) + { + case OP_RETURN: + case OP_GOTO: + case OP_DONE: + break; + default: + PRVM_ERROR("PRVM_LoadProgs: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", PRVM_NAME); + break; + } + + PRVM_LoadLNO(filename); PRVM_Init_Exec(); + if(*prvm_language.string) + // 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 = !!strcmp(PRVM_NAME, "client"); + if(!strcmp(prvm_language.string, "dump")) + { + qfile_t *f = FS_OpenRealFile(va("%s.%s.po", filename, prvm_language.string), "w", false); + Con_Printf("Dumping to %s.%s.po\n", filename, prvm_language.string); + if(f) + { + for (i=0 ; iprogs->numglobaldefs ; i++) + { + const char *name; + name = PRVM_GetString(prog->globaldefs[i].s_name); + if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12))) + if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string) + { + prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs); + const char *value = PRVM_GetString(val->string); + if(*value) + { + char buf[MAX_INPUTLINE]; + PRVM_PO_UnparseString(buf, value, sizeof(buf)); + FS_Printf(f, "msgid \"%s\"\nmsgstr \"\"\n\n", buf); + } + } + } + FS_Close(f); + } + } + else + { + po_t *po = PRVM_PO_Load(va("%s.%s.po", filename, prvm_language.string), prog->progs_mempool); + if(po) + { + for (i=0 ; iprogs->numglobaldefs ; i++) + { + const char *name; + name = PRVM_GetString(prog->globaldefs[i].s_name); + if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12))) + if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string) + { + prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs); + const char *value = PRVM_GetString(val->string); + if(*value) + { + value = PRVM_PO_Lookup(po, value); + if(value) + val->string = PRVM_SetEngineString(value); + } + } + } + } + } + } + + for (i=0 ; iprogs->numglobaldefs ; i++) + { + const char *name; + name = PRVM_GetString(prog->globaldefs[i].s_name); + //Con_Printf("found var %s\n", name); + if(name + && !strncmp(name, "autocvar_", 9) + && !(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z')) + ) + { + prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs); + cvar_t *cvar = Cvar_FindVar(name + 9); + //Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, PRVM_NAME); + if(!cvar) + { + const char *value; + char buf[64]; + Con_Printf("PRVM_LoadProgs: no cvar for autocvar global %s in %s, creating...\n", name, PRVM_NAME); + switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) + { + case ev_float: + if((float)((int)(val->_float)) == val->_float) + dpsnprintf(buf, sizeof(buf), "%i", (int)(val->_float)); + else + dpsnprintf(buf, sizeof(buf), "%.9g", val->_float); + value = buf; + break; + case ev_vector: + dpsnprintf(buf, sizeof(buf), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]); value = buf; + break; + case ev_string: + value = PRVM_GetString(val->string); + break; + default: + Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME); + goto fail; + } + cvar = Cvar_Get(name + 9, value, 0, NULL); + if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string) + { + val->string = PRVM_SetEngineString(cvar->string); + cvar->globaldefindex_stringno[prog - prog_list] = val->string; + } + if(!cvar) + PRVM_ERROR("PRVM_LoadProgs: could not create cvar for autocvar global %s in %s", name, PRVM_NAME); + cvar->globaldefindex_progid[prog - prog_list] = prog->id; + cvar->globaldefindex[prog - prog_list] = i; + } + else if((cvar->flags & CVAR_PRIVATE) == 0) + { + // MUST BE SYNCED WITH cvar.c Cvar_Set + int j; + const char *s; + switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) + { + case ev_float: + val->_float = cvar->value; + break; + case ev_vector: + s = cvar->string; + VectorClear(val->vector); + for (j = 0;j < 3;j++) + { + while (*s && ISWHITESPACE(*s)) + s++; + if (!*s) + break; + val->vector[j] = atof(s); + while (!ISWHITESPACE(*s)) + s++; + if (!*s) + break; + } + break; + case ev_string: + val->string = PRVM_SetEngineString(cvar->string); + cvar->globaldefindex_stringno[prog - prog_list] = val->string; + break; + default: + Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME); + goto fail; + } + cvar->globaldefindex_progid[prog - prog_list] = prog->id; + cvar->globaldefindex[prog - prog_list] = i; + } + else + Con_Printf("PRVM_LoadProgs: private cvar for autocvar global %s in %s\n", name, PRVM_NAME); + } +fail: + ; + } + prog->loaded = TRUE; - - // set flags & ddef_ts in prog - - prog->flag = 0; - - prog->self = PRVM_ED_FindGlobal("self"); - if(PRVM_ED_FindGlobal("time")) - prog->time = &PRVM_G_FLOAT(PRVM_ED_FindGlobal("time")->ofs); + // set flags & ddef_ts in prog - if(PRVM_ED_FindField ("chain")) - prog->flag |= PRVM_FE_CHAIN; + prog->flag = 0; - if(PRVM_ED_FindField ("classname")) - prog->flag |= PRVM_FE_CLASSNAME; + PRVM_FindOffsets(); - if(PRVM_ED_FindField ("nextthink") && PRVM_ED_FindField ("frame") && PRVM_ED_FindField ("think") - && prog->flag && prog->self) - prog->flag |= PRVM_OP_STATE; - - PRVM_GCALL(reset_cmd)(); PRVM_GCALL(init_cmd)(); // init mempools @@ -1476,7 +2476,8 @@ void PRVM_Fields_f (void) { int i, j, ednum, used, usedamount; int *counts; - char tempstring[5000], tempstring2[260], *name; + char tempstring[MAX_INPUTLINE], tempstring2[260]; + const char *name; prvm_edict_t *ed; ddef_t *d; int *v; @@ -1485,14 +2486,14 @@ void PRVM_Fields_f (void) /* if (!sv.active) { - Con_Printf("no progs loaded\n"); + Con_Print("no progs loaded\n"); return; } */ if(Cmd_Argc() != 2) { - Con_Printf("prvm_fields \n"); + Con_Print("prvm_fields \n"); return; } @@ -1500,11 +2501,11 @@ void PRVM_Fields_f (void) if(!PRVM_SetProgFromString(Cmd_Argv(1))) return; - counts = Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int)); + counts = (int *)Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int)); for (ednum = 0;ednum < prog->max_edicts;ednum++) { ed = PRVM_EDICT_NUM(ednum); - if (ed->e->free) + if (ed->priv.required->free) continue; for (i = 1;i < prog->progs->numfielddefs;i++) { @@ -1512,7 +2513,7 @@ void PRVM_Fields_f (void) name = PRVM_GetString(d->s_name); if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - v = (int *)((char *)ed->v + d->ofs*4); + v = (int *)(ed->fields.vp + d->ofs); // if the value is still all 0, skip the field for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++) { @@ -1536,50 +2537,50 @@ void PRVM_Fields_f (void) switch(d->type & ~DEF_SAVEGLOBAL) { case ev_string: - strcat(tempstring, "string "); + strlcat(tempstring, "string ", sizeof(tempstring)); break; case ev_entity: - strcat(tempstring, "entity "); + strlcat(tempstring, "entity ", sizeof(tempstring)); break; case ev_function: - strcat(tempstring, "function "); + strlcat(tempstring, "function ", sizeof(tempstring)); break; case ev_field: - strcat(tempstring, "field "); + strlcat(tempstring, "field ", sizeof(tempstring)); break; case ev_void: - strcat(tempstring, "void "); + strlcat(tempstring, "void ", sizeof(tempstring)); break; case ev_float: - strcat(tempstring, "float "); + strlcat(tempstring, "float ", sizeof(tempstring)); break; case ev_vector: - strcat(tempstring, "vector "); + strlcat(tempstring, "vector ", sizeof(tempstring)); break; case ev_pointer: - strcat(tempstring, "pointer "); + strlcat(tempstring, "pointer ", sizeof(tempstring)); break; default: - sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL); - strcat(tempstring, tempstring2); + dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL); + strlcat(tempstring, tempstring2, sizeof(tempstring)); break; } - if (strlen(name) > 256) + if (strlen(name) > sizeof(tempstring2)-4) { - strncpy(tempstring2, name, 256); - tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; - tempstring2[259] = 0; + memcpy (tempstring2, name, sizeof(tempstring2)-4); + tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.'; + tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); - for (j = strlen(name);j < 25;j++) - strcat(tempstring, " "); - sprintf(tempstring2, "%5d", counts[i]); - strcat(tempstring, tempstring2); - strcat(tempstring, "\n"); - if (strlen(tempstring) >= 4096) + strlcat(tempstring, name, sizeof(tempstring)); + for (j = (int)strlen(name);j < 25;j++) + strlcat(tempstring, " ", sizeof(tempstring)); + dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]); + strlcat(tempstring, tempstring2, sizeof(tempstring)); + strlcat(tempstring, "\n", sizeof(tempstring)); + if (strlen(tempstring) >= sizeof(tempstring)/2) { - Con_Printf("%s", tempstring); + Con_Print(tempstring); tempstring[0] = 0; } if (counts[i]) @@ -1597,15 +2598,18 @@ void PRVM_Fields_f (void) void PRVM_Globals_f (void) { int i; + const char *wildcard; + int numculled; + numculled = 0; // TODO /*if (!sv.active) { - Con_Printf("no progs loaded\n"); + Con_Print("no progs loaded\n"); return; }*/ - if(Cmd_Argc () != 2) + if(Cmd_Argc () < 2 || Cmd_Argc() > 3) { - Con_Printf("prvm_globals \n"); + Con_Print("prvm_globals \n"); return; } @@ -1613,12 +2617,75 @@ void PRVM_Globals_f (void) if(!PRVM_SetProgFromString (Cmd_Argv (1))) return; + if( Cmd_Argc() == 3) + wildcard = Cmd_Argv(2); + else + wildcard = NULL; + Con_Printf("%s :", PRVM_NAME); for (i = 0;i < prog->progs->numglobaldefs;i++) + { + if(wildcard) + if( !matchpattern( PRVM_GetString(prog->globaldefs[i].s_name), wildcard, 1) ) + { + numculled++; + continue; + } Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name)); - Con_Printf("%i global variables, totalling %i bytes\n", prog->progs->numglobals, prog->progs->numglobals * 4); + } + Con_Printf("%i global variables, %i culled, totalling %i bytes\n", prog->progs->numglobals, numculled, prog->progs->numglobals * 4); + + PRVM_End; +} + +/* +=============== +PRVM_Global +=============== +*/ +void PRVM_Global_f(void) +{ + ddef_t *global; + if( Cmd_Argc() != 3 ) { + Con_Printf( "prvm_global \n" ); + return; + } + + PRVM_Begin; + if( !PRVM_SetProgFromString( Cmd_Argv(1) ) ) + return; + + global = PRVM_ED_FindGlobal( Cmd_Argv(2) ); + if( !global ) + Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) ); + else + Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( (etype_t)global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) ); + PRVM_End; +} + +/* +=============== +PRVM_GlobalSet +=============== +*/ +void PRVM_GlobalSet_f(void) +{ + ddef_t *global; + if( Cmd_Argc() != 4 ) { + Con_Printf( "prvm_globalset \n" ); + return; + } + + PRVM_Begin; + if( !PRVM_SetProgFromString( Cmd_Argv(1) ) ) + return; + global = PRVM_ED_FindGlobal( Cmd_Argv(2) ); + if( !global ) + Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) ); + else + PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3), true ); PRVM_End; } @@ -1629,15 +2696,36 @@ PRVM_Init */ void PRVM_Init (void) { - Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f); - Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f); - Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f); - Cmd_AddCommand ("prvm_profile", PRVM_Profile_f); - Cmd_AddCommand ("prvm_fields", PRVM_Fields_f); - Cmd_AddCommand ("prvm_globals", PRVM_Globals_f); - // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others)) - Cvar_RegisterVariable (&prvm_boundscheck); + Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls"); + Cmd_AddCommand ("prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console"); + Cmd_AddCommand ("prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console"); + Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)"); + Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument"); + Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument"); + Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument"); + + Cvar_RegisterVariable (&prvm_language); 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); + Cvar_RegisterVariable (&prvm_reuseedicts_startuptime); + Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe); + + // 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(); } @@ -1649,8 +2737,10 @@ PRVM_InitProg */ void PRVM_InitProg(int prognr) { + static unsigned int progid = 0; + if(prognr < 0 || prognr >= PRVM_MAXPROGS) - Sys_Error("PRVM_InitProg: Invalid program number %i\n",prognr); + Sys_Error("PRVM_InitProg: Invalid program number %i",prognr); prog = &prog_list[prognr]; @@ -1658,66 +2748,519 @@ void PRVM_InitProg(int prognr) PRVM_ResetProg(); memset(prog, 0, sizeof(prvm_prog_t)); + prog->starttime = Sys_DoubleTime(); + prog->id = ++progid; - prog->time = &prog->_time; + prog->error_cmd = Host_Error; + prog->leaktest_active = prvm_leaktest.integer != 0; } -int PRVM_GetProgNr() +int PRVM_GetProgNr(void) { return prog - prog_list; } +void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline) +{ + return _Mem_Alloc(prog->progs_mempool, NULL, buffersize, 16, filename, fileline); +} + +void _PRVM_Free(void *buffer, const char *filename, int fileline) +{ + _Mem_Free(buffer, filename, fileline); +} + +void _PRVM_FreeAll(const char *filename, int fileline) +{ + prog->progs = NULL; + prog->fielddefs = NULL; + prog->functions = NULL; + _Mem_EmptyPool(prog->progs_mempool, filename, fileline); +} + // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons -prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline) +unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, char *filename, int fileline) { PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline); - return NULL; + return 0; } -void PRVM_ProcessError(void) +sizebuf_t vm_tempstringsbuf; +#define PRVM_KNOWNSTRINGBASE 0x40000000 + +const char *PRVM_GetString(int num) { - if(prog) - PRVM_GCALL(error_cmd)(); + if (num < 0) + { + // invalid + VM_Warning("PRVM_GetString: Invalid string offset (%i < 0)\n", num); + return ""; + } + else if (num < prog->stringssize) + { + // constant string from progs.dat + return prog->strings + num; + } + else if (num <= prog->stringssize + vm_tempstringsbuf.maxsize) + { + // tempstring returned by engine to QC (becomes invalid after returning to engine) + num -= prog->stringssize; + if (num < vm_tempstringsbuf.cursize) + return (char *)vm_tempstringsbuf.data + num; + else + { + VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize); + return ""; + } + } + else if (num & PRVM_KNOWNSTRINGBASE) + { + // allocated string + num = num - PRVM_KNOWNSTRINGBASE; + if (num >= 0 && num < prog->numknownstrings) + { + if (!prog->knownstrings[num]) + { + VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num); + return ""; + } + return prog->knownstrings[num]; + } + else + { + VM_Warning("PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings); + return ""; + } + } + else + { + // invalid string offset + VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize); + return ""; + } } -/* -int NUM_FOR_EDICT_ERROR(edict_t *e) +const char *PRVM_ChangeEngineString(int i, const char *s) { - Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts); - return 0; + const char *old; + i = i - PRVM_KNOWNSTRINGBASE; + if(i < 0 || i >= prog->numknownstrings) + PRVM_ERROR("PRVM_ChangeEngineString: s is not an engine string"); + old = prog->knownstrings[i]; + prog->knownstrings[i] = s; + return old; } -int NUM_FOR_EDICT(edict_t *e) +int PRVM_SetEngineString(const char *s) { - int n; - n = e - sv.edicts; - if ((unsigned int)n >= MAX_EDICTS) - Host_Error ("NUM_FOR_EDICT: bad pointer"); - return n; + int i; + if (!s) + return 0; + if (s >= prog->strings && s <= prog->strings + prog->stringssize) + PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area"); + // if it's in the tempstrings area, use a reserved range + // (otherwise we'd get millions of useless string offsets cluttering the database) + if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize) +#if 1 + return prog->stringssize + (s - (char *)vm_tempstringsbuf.data); +#endif + // see if it's a known string address + for (i = 0;i < prog->numknownstrings;i++) + if (prog->knownstrings[i] == s) + return PRVM_KNOWNSTRINGBASE + i; + // new unknown engine string + if (developer_insane.integer) + Con_DPrintf("new engine string %p = \"%s\"\n", s, s); + for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++) + if (!prog->knownstrings[i]) + break; + if (i >= prog->numknownstrings) + { + if (i >= prog->maxknownstrings) + { + const char **oldstrings = prog->knownstrings; + const unsigned char *oldstrings_freeable = prog->knownstrings_freeable; + const char **oldstrings_origin = prog->knownstrings_origin; + prog->maxknownstrings += 128; + prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char)); + if(prog->leaktest_active) + prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + if (prog->numknownstrings) + { + memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *)); + memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char)); + if(prog->leaktest_active) + memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *)); + } + } + prog->numknownstrings++; + } + prog->firstfreeknownstring = i + 1; + prog->knownstrings[i] = s; + prog->knownstrings_freeable[i] = false; + if(prog->leaktest_active) + prog->knownstrings_origin[i] = NULL; + return PRVM_KNOWNSTRINGBASE + i; } -//int NoCrash_NUM_FOR_EDICT(edict_t *e) -//{ -// return e - sv.edicts; -//} +// temp string handling + +// all tempstrings go into this buffer consecutively, and it is reset +// whenever PRVM_ExecuteProgram returns to the engine +// (technically each PRVM_ExecuteProgram call saves the cursize value and +// restores it on return, so multiple recursive calls can share the same +// buffer) +// the buffer size is automatically grown as needed -//#define EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields)) -//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4))) -int EDICT_TO_PROG(edict_t *e) +int PRVM_SetTempString(const char *s) { - int n; - n = e - sv.edicts; - if ((unsigned int)n >= (unsigned int)sv.max_edicts) - Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts); - return n;// EXPERIMENTAL - //return (qbyte *)e->v - (qbyte *)sv.edictsfields; + int size; + char *t; + if (!s) + return 0; + size = (int)strlen(s) + 1; + if (developer_insane.integer) + Con_DPrintf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size); + if (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size) + { + sizebuf_t old = vm_tempstringsbuf; + if (vm_tempstringsbuf.cursize + size >= 1<<28) + PRVM_ERROR("PRVM_SetTempString: ran out of tempstring memory! (refusing to grow tempstring buffer over 256MB, cursize %i, size %i)\n", vm_tempstringsbuf.cursize, size); + vm_tempstringsbuf.maxsize = max(vm_tempstringsbuf.maxsize, 65536); + while (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size) + vm_tempstringsbuf.maxsize *= 2; + if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL) + { + Con_DPrintf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024); + 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) + Mem_Free(old.data); + } + } + t = (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.cursize; + memcpy(t, s, size); + vm_tempstringsbuf.cursize += size; + return PRVM_SetEngineString(t); +} + +int PRVM_AllocString(size_t bufferlength, char **pointer) +{ + int i; + if (!bufferlength) + return 0; + for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++) + if (!prog->knownstrings[i]) + break; + if (i >= prog->numknownstrings) + { + if (i >= prog->maxknownstrings) + { + const char **oldstrings = prog->knownstrings; + const unsigned char *oldstrings_freeable = prog->knownstrings_freeable; + const char **oldstrings_origin = prog->knownstrings_origin; + prog->maxknownstrings += 128; + prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char)); + if(prog->leaktest_active) + prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + if (prog->numknownstrings) + { + memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *)); + memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char)); + if(prog->leaktest_active) + memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *)); + } + if (oldstrings) + Mem_Free((char **)oldstrings); + if (oldstrings_freeable) + Mem_Free((unsigned char *)oldstrings_freeable); + if (oldstrings_origin) + Mem_Free((char **)oldstrings_origin); + } + prog->numknownstrings++; + } + prog->firstfreeknownstring = i + 1; + prog->knownstrings[i] = (char *)PRVM_Alloc(bufferlength); + prog->knownstrings_freeable[i] = true; + if(prog->leaktest_active) + prog->knownstrings_origin[i] = PRVM_AllocationOrigin(); + if (pointer) + *pointer = (char *)(prog->knownstrings[i]); + return PRVM_KNOWNSTRINGBASE + i; } -edict_t *PROG_TO_EDICT(int n) + +void PRVM_FreeString(int num) { - if ((unsigned int)n >= (unsigned int)sv.max_edicts) - Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n); - return sv.edicts + n; // EXPERIMENTAL - //return sv.edicts + ((n) / (progs->entityfields * 4)); + if (num == 0) + PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string"); + else if (num >= 0 && num < prog->stringssize) + PRVM_ERROR("PRVM_FreeString: attempt to free a constant string"); + else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings) + { + num = num - PRVM_KNOWNSTRINGBASE; + if (!prog->knownstrings[num]) + PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string"); + if (!prog->knownstrings_freeable[num]) + PRVM_ERROR("PRVM_FreeString: attempt to free a string owned by the engine"); + PRVM_Free((char *)prog->knownstrings[num]); + if(prog->leaktest_active) + if(prog->knownstrings_origin[num]) + PRVM_Free((char *)prog->knownstrings_origin[num]); + prog->knownstrings[num] = NULL; + prog->knownstrings_freeable[num] = false; + prog->firstfreeknownstring = min(prog->firstfreeknownstring, num); + } + else + PRVM_ERROR("PRVM_FreeString: invalid string offset %i", num); } -*/ +static qboolean PRVM_IsStringReferenced(string_t string) +{ + int i, j; + + for (i = 0;i < prog->progs->numglobaldefs;i++) + { + ddef_t *d = &prog->globaldefs[i]; + if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string) + continue; + if(string == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->string) + return true; + } + + for(j = 0; j < prog->num_edicts; ++j) + { + prvm_edict_t *ed = PRVM_EDICT_NUM(j); + if (ed->priv.required->free) + continue; + for (i=0; iprogs->numfielddefs; ++i) + { + ddef_t *d = &prog->fielddefs[i]; + if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string) + continue; + if(string == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->string) + return true; + } + } + + return false; +} + +static qboolean PRVM_IsEdictRelevant(prvm_edict_t *edict) +{ + if(PRVM_NUM_FOR_EDICT(edict) <= prog->reserved_edicts) + return true; // world or clients + switch(prog - prog_list) + { + case PRVM_SERVERPROG: + { + entvars_t *ev = edict->fields.server; + if(ev->solid) // can block other stuff, or is a trigger? + return true; + if(ev->modelindex) // visible ent? + return true; + if(ev->effects) // particle effect? + return true; + if(ev->think) // has a think function? + if(ev->nextthink > 0) // that actually will eventually run? + return true; + if(ev->takedamage) + return true; + if(*prvm_leaktest_ignore_classnames.string) + { + if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname)))) + return true; + } + } + break; + case PRVM_CLIENTPROG: + { + // 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? + return true; + if(ev->think) // has a think function? + if(ev->nextthink > 0) // that actually will eventually run? + return true; + if(*prvm_leaktest_ignore_classnames.string) + { + if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname)))) + return true; + } + } + break; + case PRVM_MENUPROG: + // menu prog does not have classnames + break; + } + return false; +} + +static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark) +{ + int i, j; + int edictnum = PRVM_NUM_FOR_EDICT(edict); + const char *targetname = NULL; + + switch(prog - prog_list) + { + case PRVM_SERVERPROG: + targetname = PRVM_GetString(edict->fields.server->targetname); + break; + } + + if(targetname) + if(!*targetname) // "" + targetname = NULL; + + for (i = 0;i < prog->progs->numglobaldefs;i++) + { + ddef_t *d = &prog->globaldefs[i]; + if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity) + continue; + if(edictnum == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->edict) + return true; + } + + for(j = 0; j < prog->num_edicts; ++j) + { + prvm_edict_t *ed = PRVM_EDICT_NUM(j); + if (ed->priv.required->mark < mark) + continue; + if(ed == edict) + continue; + if(targetname) + { + const char *target = PRVM_GetString(ed->fields.server->target); + if(target) + if(!strcmp(target, targetname)) + return true; + } + for (i=0; iprogs->numfielddefs; ++i) + { + ddef_t *d = &prog->fielddefs[i]; + if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity) + continue; + if(edictnum == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->edict) + return true; + } + } + + return false; +} + +static void PRVM_MarkReferencedEdicts(void) +{ + int j; + qboolean found_new; + int stage; + + for(j = 0; j < prog->num_edicts; ++j) + { + prvm_edict_t *ed = PRVM_EDICT_NUM(j); + if(ed->priv.required->free) + continue; + ed->priv.required->mark = PRVM_IsEdictRelevant(ed) ? 1 : 0; + } + + stage = 1; + do + { + found_new = false; + for(j = 0; j < prog->num_edicts; ++j) + { + prvm_edict_t *ed = PRVM_EDICT_NUM(j); + if(ed->priv.required->free) + continue; + if(ed->priv.required->mark) + continue; + if(PRVM_IsEdictReferenced(ed, stage)) + { + ed->priv.required->mark = stage + 1; + found_new = true; + } + } + ++stage; + } + while(found_new); + Con_DPrintf("leak check used %d stages to find all references\n", stage); +} + +void PRVM_LeakTest(void) +{ + int i, j; + qboolean leaked = false; + + if(!prog->leaktest_active) + return; + + // 1. Strings + for (i = 0; i < prog->numknownstrings; ++i) + { + if(prog->knownstrings[i]) + if(prog->knownstrings_freeable[i]) + if(prog->knownstrings_origin[i]) + if(!PRVM_IsStringReferenced(-1 - i)) + { + Con_Printf("Unreferenced string found!\n Value: %s\n Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]); + leaked = true; + } + } + + // 2. Edicts + PRVM_MarkReferencedEdicts(); + for(j = 0; j < prog->num_edicts; ++j) + { + prvm_edict_t *ed = PRVM_EDICT_NUM(j); + if(ed->priv.required->free) + continue; + if(!ed->priv.required->mark) + if(ed->priv.required->allocation_origin) + { + Con_Printf("Unreferenced edict found!\n Allocated at: %s\n", ed->priv.required->allocation_origin); + PRVM_ED_Print(ed, NULL); + Con_Print("\n"); + leaked = true; + } + } + + for (i = 0; i < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray); ++i) + { + prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i); + if(stringbuffer) + if(stringbuffer->origin) + { + Con_Printf("Open string buffer handle found!\n Allocated at: %s\n", stringbuffer->origin); + leaked = true; + } + } + + for(i = 0; i < PRVM_MAX_OPENFILES; ++i) + { + if(prog->openfiles[i]) + if(prog->openfiles_origin[i]) + { + Con_Printf("Open file handle found!\n Allocated at: %s\n", prog->openfiles_origin[i]); + leaked = true; + } + } + + for(i = 0; i < PRVM_MAX_OPENSEARCHES; ++i) + { + if(prog->opensearches[i]) + if(prog->opensearches_origin[i]) + { + Con_Printf("Open search handle found!\n Allocated at: %s\n", prog->opensearches_origin[i]); + leaked = true; + } + } + + if(!leaked) + Con_Printf("Congratulations. No leaks found.\n"); +}