X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=d00023dd11ee68e2d101f0c93ce773e491f41dd0;hp=c6a1a8590c6357f4d5c3cc6c679fb252ea7a08a3;hb=a19aff1dcea954e83a41c92af13882234c7fc9fd;hpb=b580442d0be79e1c4c78b9cb568fe30cf3e03f76 diff --git a/prvm_edict.c b/prvm_edict.c index c6a1a859..d00023dd 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -31,11 +31,12 @@ int prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(v ddef_t *PRVM_ED_FieldAtOfs(int ofs); qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash); -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"}; +cvar_t prvm_language = {CVAR_SAVE, "prvm_language", "", "when set, loads progs.dat.LANGUAGENAME.po for string translations; when set to dump, progs.dat.pot is written from the strings in the progs"}; // LordHavoc: prints every opcode as it executes - warning: this is significant spew cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"}; // LordHavoc: counts usage of each QuakeC statement cvar_t prvm_statementprofiling = {0, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"}; +cvar_t prvm_timeprofiling = {0, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"}; cvar_t prvm_backtraceforwarnings = {0, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"}; cvar_t prvm_leaktest = {0, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"}; cvar_t prvm_leaktest_ignore_classnames = {0, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"}; @@ -43,12 +44,9 @@ cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to 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"}; +static double prvm_reuseedicts_always_allow = 0; qboolean prvm_runawaycheck = true; -// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others)) -// enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer) -qboolean prvm_boundscheck = true; - extern sizebuf_t vm_tempstringsbuf; //============================================================================ @@ -243,6 +241,8 @@ 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) @@ -549,10 +549,10 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val) dpsnprintf (line, sizeof (line), "void"); break; case ev_float: - dpsnprintf (line, sizeof (line), "%f", val->_float); + dpsnprintf (line, sizeof (line), "%.9g", val->_float); break; case ev_vector: - dpsnprintf (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: dpsnprintf (line, sizeof (line), "bad type %i", type); @@ -648,7 +648,7 @@ void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname) { d = &prog->fielddefs[i]; name = PRVM_GetString(d->s_name); - if (name[strlen(name)-2] == '_') + if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z') continue; // skip _x, _y, _z vars // Check Field Name Wildcard @@ -732,8 +732,9 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) 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 + //if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z') + if(strlen(name) > 1 && name[strlen(name)-2] == '_') + continue; // skip _x, _y, _z vars, and ALSO other _? vars as some mods expect them to be never saved (TODO: a gameplayfix for using the "more precise" condition above?) v = (int *)(ed->fields.vp + d->ofs); @@ -1182,7 +1183,7 @@ void PRVM_ED_EdictGet_f(void) } v = (prvm_eval_t *)(ed->fields.vp + key->ofs); - s = PRVM_UglyValueString(key->type, v); + s = PRVM_UglyValueString((etype_t)key->type, v); if(Cmd_Argc() == 5) { cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4)); @@ -1227,7 +1228,7 @@ void PRVM_ED_GlobalGet_f(void) } v = (prvm_eval_t *) &prog->globals.generic[key->ofs]; - s = PRVM_UglyValueString(key->type, v); + s = PRVM_UglyValueString((etype_t)key->type, v); if(Cmd_Argc() == 4) { cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3)); @@ -1406,6 +1407,7 @@ void PRVM_ED_LoadFromFile (const char *data) spawned = 0; died = 0; + prvm_reuseedicts_always_allow = realtime; // parse ents while (1) @@ -1486,7 +1488,7 @@ void PRVM_ED_LoadFromFile (const char *data) } else { - if (developer.integer) // don't confuse non-developers with errors + if (developer.integer > 0) // don't confuse non-developers with errors { Con_Print("No spawn function for:\n"); PRVM_ED_Print(ent, NULL); @@ -1517,6 +1519,8 @@ void PRVM_ED_LoadFromFile (const char *data) } 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) @@ -1573,6 +1577,7 @@ void PRVM_FindOffsets(void) 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.discardabledemo = PRVM_ED_FindFieldOffset("discardabledemo"); prog->fieldoffsets.dphitcontentsmask = PRVM_ED_FindFieldOffset("dphitcontentsmask"); prog->fieldoffsets.drawonlytoclient = PRVM_ED_FindFieldOffset("drawonlytoclient"); prog->fieldoffsets.exteriormodeltoclient = PRVM_ED_FindFieldOffset("exteriormodeltoclient"); @@ -1652,6 +1657,18 @@ void PRVM_FindOffsets(void) prog->fieldoffsets.jointtype = PRVM_ED_FindFieldOffset("jointtype"); prog->fieldoffsets.movedir = PRVM_ED_FindFieldOffset("movedir"); + prog->fieldoffsets.camera_transform = PRVM_ED_FindFieldOffset("camera_transform"); + prog->fieldoffsets.userwavefunc_param0 = PRVM_ED_FindFieldOffset("userwavefunc_param0"); + prog->fieldoffsets.userwavefunc_param1 = PRVM_ED_FindFieldOffset("userwavefunc_param1"); + prog->fieldoffsets.userwavefunc_param2 = PRVM_ED_FindFieldOffset("userwavefunc_param2"); + prog->fieldoffsets.userwavefunc_param3 = PRVM_ED_FindFieldOffset("userwavefunc_param3"); + + prog->fieldoffsets.crypto_keyfp = PRVM_ED_FindFieldOffset("crypto_keyfp"); + prog->fieldoffsets.crypto_mykeyfp = PRVM_ED_FindFieldOffset("crypto_mykeyfp"); + prog->fieldoffsets.crypto_idfp = PRVM_ED_FindFieldOffset("crypto_idfp"); + prog->fieldoffsets.crypto_encryptmethod = PRVM_ED_FindFieldOffset("crypto_encryptmethod"); + prog->fieldoffsets.crypto_signmethod = PRVM_ED_FindFieldOffset("crypto_signmethod"); + 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"); @@ -1720,7 +1737,13 @@ void PRVM_FindOffsets(void) 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.view_punchangle = PRVM_ED_FindGlobalOffset("view_punchangle"); + prog->globaloffsets.view_punchvector = PRVM_ED_FindGlobalOffset("view_punchvector"); prog->globaloffsets.worldstatus = PRVM_ED_FindGlobalOffset("worldstatus"); + prog->globaloffsets.particles_alphamin = PRVM_ED_FindGlobalOffset("particles_alphamin"); + prog->globaloffsets.particles_alphamax = PRVM_ED_FindGlobalOffset("particles_alphamax"); + prog->globaloffsets.particles_colormin = PRVM_ED_FindGlobalOffset("particles_colormin"); + prog->globaloffsets.particles_colormax = PRVM_ED_FindGlobalOffset("particles_colormax"); // menu qc only uses some functions, nothing else prog->funcoffsets.m_draw = PRVM_ED_FindFunctionOffset("m_draw"); @@ -1729,6 +1752,7 @@ void PRVM_FindOffsets(void) 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"); + prog->funcoffsets.m_newmap = PRVM_ED_FindFunctionOffset("m_newmap"); } // not used @@ -1880,7 +1904,9 @@ po_t *PRVM_PO_Load(const char *filename, mempool_t *pool) if(!buf) return NULL; - po = Mem_Alloc(pool, sizeof(*po)); + memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning + + po = (po_t *)Mem_Alloc(pool, sizeof(*po)); memset(po, 0, sizeof(*po)); p = buf; @@ -1944,16 +1970,16 @@ po_t *PRVM_PO_Load(const char *filename, mempool_t *pool) { if(thisstr.key) Mem_Free(thisstr.key); - thisstr.key = Mem_Alloc(pool, decodedpos + 1); + thisstr.key = (char *)Mem_Alloc(pool, decodedpos + 1); memcpy(thisstr.key, decodedbuf, decodedpos + 1); } else if(decodedpos > 0 && thisstr.key) // skip empty translation results { - thisstr.value = Mem_Alloc(pool, decodedpos + 1); + thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1); memcpy(thisstr.value, decodedbuf, decodedpos + 1); hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE; thisstr.nextonhashchain = po->hashtable[hashindex]; - po->hashtable[hashindex] = Mem_Alloc(pool, sizeof(thisstr)); + po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr)); memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr)); memset(&thisstr, 0, sizeof(thisstr)); } @@ -2056,7 +2082,7 @@ void PRVM_LoadLNO( const char *progname ) { PRVM_LoadProgs =============== */ -void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global) +void PRVM_LoadProgs (const char * filename, int numrequiredfunc, const char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global) { int i; dstatement_t *st; @@ -2309,10 +2335,24 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required // later idea: include a list of authorized .po file checksums with the csprogs { qboolean deftrans = !!strcmp(PRVM_NAME, "client"); + if(deftrans) // once we have dotranslate_ strings, ALWAYS use the opt-in method! + { + for (i=0 ; iprogs->numglobaldefs ; i++) + { + const char *name; + name = PRVM_GetString(prog->globaldefs[i].s_name); + if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string) + if(name && !strncmp(name, "dotranslate_", 12)) + { + deftrans = false; + break; + } + } + } 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); + qfile_t *f = FS_OpenRealFile(va("%s.pot", filename), "w", false); + Con_Printf("Dumping to %s.pot\n", filename); if(f) { for (i=0 ; iprogs->numglobaldefs ; i++) @@ -2378,18 +2418,18 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required { const char *value; char buf[64]; - Con_Printf("PRVM_LoadProgs: no cvar for autocvar global %s in %s, creating...\n", name, PRVM_NAME); + Con_DPrintf("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), "%f", val->_float); + dpsnprintf(buf, sizeof(buf), "%.9g", val->_float); value = buf; break; case ev_vector: - dpsnprintf(buf, sizeof(buf), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); value = buf; + 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); @@ -2710,12 +2750,10 @@ void PRVM_Init (void) 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"); - // COMMANDLINEOPTION: PRVM: -noboundscheck disables the bounds checks (security hole if CSQC is in use!) - prvm_boundscheck = !COM_CheckParm("-noboundscheck"); - Cvar_RegisterVariable (&prvm_language); Cvar_RegisterVariable (&prvm_traceqc); Cvar_RegisterVariable (&prvm_statementprofiling); + Cvar_RegisterVariable (&prvm_timeprofiling); Cvar_RegisterVariable (&prvm_backtraceforwarnings); Cvar_RegisterVariable (&prvm_leaktest); Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames); @@ -2778,59 +2816,45 @@ void _PRVM_FreeAll(const char *filename, int fileline) } // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons -unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, char *filename, int fileline) +unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, const char *filename, int fileline) { PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline); return 0; } sizebuf_t vm_tempstringsbuf; +#define PRVM_KNOWNSTRINGBASE 0x40000000 const char *PRVM_GetString(int num) { - if (num >= 0) + if (num < 0) { - if (num < prog->stringssize) - return prog->strings + num; - else -#if 1 - if (num <= prog->stringssize + vm_tempstringsbuf.maxsize) - { - 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 ""; - } - } + // 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 -#endif { - VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize); + VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize); return ""; } } - else + else if (num & PRVM_KNOWNSTRINGBASE) { - num = -1 - num; -#if 0 - if (num >= (1<<30)) - { - // special range reserved for tempstrings - num -= (1<<30); - 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 -#endif - if (num < prog->numknownstrings) + // allocated string + num = num - PRVM_KNOWNSTRINGBASE; + if (num >= 0 && num < prog->numknownstrings) { if (!prog->knownstrings[num]) { @@ -2845,12 +2869,18 @@ const char *PRVM_GetString(int num) return ""; } } + else + { + // invalid string offset + VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize); + return ""; + } } const char *PRVM_ChangeEngineString(int i, const char *s) { const char *old; - i = -1 - i; + i = i - PRVM_KNOWNSTRINGBASE; if(i < 0 || i >= prog->numknownstrings) PRVM_ERROR("PRVM_ChangeEngineString: s is not an engine string"); old = prog->knownstrings[i]; @@ -2870,16 +2900,14 @@ int PRVM_SetEngineString(const char *s) if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize) #if 1 return prog->stringssize + (s - (char *)vm_tempstringsbuf.data); -#else - return -1 - ((1<<30) + (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 -1 - i; + return PRVM_KNOWNSTRINGBASE + i; // new unknown engine string - if (developer.integer >= 200) - Con_Printf("new engine string %p = \"%s\"\n", s, s); + 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; @@ -2910,7 +2938,7 @@ int PRVM_SetEngineString(const char *s) prog->knownstrings_freeable[i] = false; if(prog->leaktest_active) prog->knownstrings_origin[i] = NULL; - return -1 - i; + return PRVM_KNOWNSTRINGBASE + i; } // temp string handling @@ -2929,8 +2957,8 @@ int PRVM_SetTempString(const char *s) if (!s) return 0; size = (int)strlen(s) + 1; - if (developer.integer >= 300) - Con_Printf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size); + 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; @@ -2941,8 +2969,7 @@ int PRVM_SetTempString(const char *s) vm_tempstringsbuf.maxsize *= 2; if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL) { - if (developer.integer >= 100) - Con_Printf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024); + 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); @@ -2983,7 +3010,12 @@ int PRVM_AllocString(size_t bufferlength, char **pointer) if(prog->leaktest_active) memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *)); } - // TODO why not Mem_Free the old ones? + 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++; } @@ -2994,7 +3026,7 @@ int PRVM_AllocString(size_t bufferlength, char **pointer) prog->knownstrings_origin[i] = PRVM_AllocationOrigin(); if (pointer) *pointer = (char *)(prog->knownstrings[i]); - return -1 - i; + return PRVM_KNOWNSTRINGBASE + i; } void PRVM_FreeString(int num) @@ -3003,9 +3035,9 @@ void PRVM_FreeString(int num) 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 < 0 && num >= -prog->numknownstrings) + else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings) { - num = -1 - num; + 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]) @@ -3211,7 +3243,7 @@ void PRVM_LeakTest(void) if(prog->knownstrings[i]) if(prog->knownstrings_freeable[i]) if(prog->knownstrings_origin[i]) - if(!PRVM_IsStringReferenced(-1 - i)) + if(!PRVM_IsStringReferenced(PRVM_KNOWNSTRINGBASE + i)) { Con_Printf("Unreferenced string found!\n Value: %s\n Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]); leaked = true;