X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=prvm_edict.c;h=18238abb3dd57072645459657269bf5ef1169880;hb=9829ccb76b1b5f2cb18d14cae0092ab94f183ece;hp=8b4ddf0a5bd6073d8c72064d5c3ba63c9b284780;hpb=63049d016df231bb7b125024ed8a1d11a323a83d;p=xonotic%2Fdarkplaces.git

diff --git a/prvm_edict.c b/prvm_edict.c
index 8b4ddf0a..18238abb 100644
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -31,10 +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 = {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)"};
@@ -42,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;
 
 //============================================================================
@@ -242,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)
@@ -548,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);
@@ -647,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
@@ -731,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);
 
@@ -1181,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));
@@ -1226,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));
@@ -1405,6 +1407,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 	spawned = 0;
 	died = 0;
 
+	prvm_reuseedicts_always_allow = realtime;
 
 // parse ents
 	while (1)
@@ -1485,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);
@@ -1516,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)
@@ -1572,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");
@@ -1609,6 +1615,8 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1649,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");
@@ -1683,6 +1703,7 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1716,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");
@@ -1725,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
@@ -1749,12 +1777,255 @@ PRVM_ResetProg
 ===============
 */
 
+#define PO_HASHSIZE 16384
+typedef struct po_string_s
+{
+	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;
+
+	memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning
+
+	po = (po_t *)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 = (char *)Mem_Alloc(pool, decodedpos + 1);
+			memcpy(thisstr.key, decodedbuf, decodedpos + 1);
+		}
+		else if(decodedpos > 0 && thisstr.key) // skip empty translation results
+		{
+			thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1);
+			memcpy(thisstr.value, decodedbuf, decodedpos + 1);
+			hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
+			thisstr.nextonhashchain = po->hashtable[hashindex];
+			po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr));
+			memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
+			memset(&thisstr, 0, sizeof(thisstr));
+		}
+	}
+	
+	Mem_Free((char *) buf);
+	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();
 }
@@ -1811,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;
@@ -2059,6 +2330,77 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
 	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(deftrans) // once we have dotranslate_ strings, ALWAYS use the opt-in method!
+		{
+			for (i=0 ; i<prog->progs->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.pot", filename), "w", false);
+			Con_Printf("Dumping to %s.pot\n", filename);
+			if(f)
+			{
+				for (i=0 ; i<prog->progs->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 ; i<prog->progs->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 ; i<prog->progs->numglobaldefs ; i++)
 	{
 		const char *name;
@@ -2076,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);
@@ -2408,11 +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);
@@ -2475,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])
 			{
@@ -2542,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];
@@ -2567,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;
@@ -2607,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
@@ -2626,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;
@@ -2638,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);
@@ -2680,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++;
 	}
@@ -2691,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)
@@ -2700,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])
@@ -2908,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;