X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=d00023dd11ee68e2d101f0c93ce773e491f41dd0;hp=38062060f598d0f630a16dc8785b73e0bcef5d2b;hb=a19aff1dcea954e83a41c92af13882234c7fc9fd;hpb=7f5c1fd5b6ae8026c2a48781c0aac42c33371f84

diff --git a/prvm_edict.c b/prvm_edict.c
index 38062060..d00023dd 100644
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -29,17 +29,23 @@ 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))
-#ifdef PRVM_BOUNDSCHECK_CVAR
-cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1", "enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer)"};
-#endif
+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)"};
+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"};
+
+static double prvm_reuseedicts_always_allow = 0;
+qboolean prvm_runawaycheck = true;
 
 extern sizebuf_t vm_tempstringsbuf;
 
@@ -70,13 +76,14 @@ void PRVM_MEM_Alloc(void)
 	prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
 
 	// alloc edict fields
-	prog->edictsfields = Mem_Alloc(prog->progs_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].priv.required = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
 	}
 }
 
@@ -88,9 +95,6 @@ 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;
@@ -100,23 +104,18 @@ void PRVM_MEM_IncreaseEdicts(void)
 	// increase edicts
 	prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
 
-	prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
-	prog->edictprivate = Mem_Alloc(prog->progs_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].priv.required  = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
 	}
 
 	PRVM_GCALL(end_increase_edicts)();
-
-	Mem_Free(oldedictsfields);
-	Mem_Free(oldedictprivate);
 }
 
 //============================================================================
@@ -219,6 +218,40 @@ void PRVM_ED_ClearEdict (prvm_edict_t *e)
 	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
+}
+
 /*
 =================
 PRVM_ED_Alloc
@@ -243,11 +276,10 @@ prvm_edict_t *PRVM_ED_Alloc (void)
 	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->priv.required->free && ( e->priv.required->freetime < 2 || prog->globaloffsets.time < 0 || (PRVM_GLOBALFIELDVALUE(prog->globaloffsets.time)->_float - e->priv.required->freetime) > 0.5 ) )
+		if(PRVM_ED_CanAlloc(e))
 		{
 			PRVM_ED_ClearEdict (e);
+			e->priv.required->allocation_origin = PRVM_AllocationOrigin();
 			return e;
 		}
 	}
@@ -262,6 +294,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;
 }
 
@@ -282,7 +316,12 @@ void PRVM_ED_Free (prvm_edict_t *ed)
 	PRVM_GCALL(free_edict)(ed);
 
 	ed->priv.required->free = true;
-	ed->priv.required->freetime = prog->globaloffsets.time >= 0 ? PRVM_GLOBALFIELDVALUE(prog->globaloffsets.time)->_float : 0;
+	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;
+	}
 }
 
 //===========================================================================
@@ -407,35 +446,35 @@ char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
 		break;
 	case ev_entity:
 		n = val->edict;
-		if (n < 0 || n >= prog->limit_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", (int) type);
+		dpsnprintf (line, sizeof(line), "bad type %i", (int) type);
 		break;
 	}
 
@@ -479,6 +518,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++;
@@ -500,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);
@@ -532,11 +581,11 @@ char *PRVM_GlobalString (int ofs)
 	val = (void *)&prog->globals.generic[ofs];
 	def = PRVM_ED_GlobalAtOfs(ofs);
 	if (!def)
-		sprintf (line,"GLOBAL%i", ofs);
+		dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs);
 	else
 	{
 		s = PRVM_ValueString ((etype_t)def->type, (prvm_eval_t *)val);
-		sprintf (line,"%s (=%s)", PRVM_GetString(def->s_name), s);
+		dpsnprintf (line, sizeof(line), "%s (=%s)", PRVM_GetString(def->s_name), s);
 	}
 
 	//i = strlen(line);
@@ -555,9 +604,9 @@ char *PRVM_GlobalStringNoContents (int ofs)
 
 	def = PRVM_ED_GlobalAtOfs(ofs);
 	if (!def)
-		sprintf (line,"GLOBAL%i", ofs);
+		dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs);
 	else
-		sprintf (line,"%s", PRVM_GetString(def->s_name));
+		dpsnprintf (line, sizeof(line), "%s", PRVM_GetString(def->s_name));
 
 	//i = strlen(line);
 	//for ( ; i<20 ; i++)
@@ -594,12 +643,12 @@ void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname)
 	}
 
 	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 ; i<prog->progs->numfielddefs ; i++)
 	{
 		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
@@ -608,7 +657,7 @@ void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname)
 				// Didn't match; skip
 				continue;
 
-		v = (int *)((char *)ed->fields.vp + 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;
@@ -658,6 +707,7 @@ PRVM_ED_Write
 For savegames
 =============
 */
+extern cvar_t developer_entityparsing;
 void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 {
 	ddef_t	*d;
@@ -678,10 +728,15 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 	{
 		d = &prog->fielddefs[i];
 		name = PRVM_GetString(d->s_name);
-		if (name[strlen(name)-2] == '_')
-			continue;	// skip _x, _y, _z vars
 
-		v = (int *)((char *)ed->fields.vp + d->ofs*4);
+		if(developer_entityparsing.integer)
+			Con_Printf("PRVM_ED_Write: at entity %d field %s\n", PRVM_NUM_FOR_EDICT(ed), name);
+
+		//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);
 
 	// if the value is still all 0, skip the field
 		type = d->type & ~DEF_SAVEGLOBAL;
@@ -692,7 +747,9 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 			continue;
 
 		FS_Printf(f,"\"%s\" ",name);
+		prog->statestring = va("PRVM_ED_Write, ent=%d, name=%s", i, name);
 		FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
+		prog->statestring = NULL;
 	}
 
 	FS_Print(f, "}\n");
@@ -856,8 +913,14 @@ void PRVM_ED_WriteGlobals (qfile_t *f)
 			continue;
 
 		name = PRVM_GetString(def->s_name);
+
+		if(developer_entityparsing.integer)
+			Con_Printf("PRVM_ED_WriteGlobals: at global %s\n", name);
+
+		prog->statestring = va("PRVM_ED_WriteGlobals, name=%s", name);
 		FS_Printf(f,"\"%s\" ", name);
 		FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
+		prog->statestring = NULL;
 	}
 	FS_Print(f,"}\n");
 }
@@ -880,12 +943,18 @@ void PRVM_ED_ParseGlobals (const char *data)
 		if (com_token[0] == '}')
 			break;
 
+		if (developer_entityparsing.integer)
+			Con_Printf("Key: \"%s\"", com_token);
+
 		strlcpy (keyname, com_token, sizeof(keyname));
 
 		// parse value
 		if (!COM_ParseToken_Simple(&data, false, true))
 			PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
 
+		if (developer_entityparsing.integer)
+			Con_Printf(" \"%s\"\n", com_token);
+
 		if (com_token[0] == '}')
 			PRVM_ERROR ("PRVM_ED_ParseGlobals: closing brace without data");
 
@@ -896,7 +965,7 @@ void PRVM_ED_ParseGlobals (const char *data)
 			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");
 	}
 }
@@ -912,7 +981,7 @@ 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, l;
 	char *new_p;
@@ -921,9 +990,9 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 	mfunction_t *func;
 
 	if (ent)
-		val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
+		val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
 	else
-		val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs);
+		val = (prvm_eval_t *)(prog->globals.generic + key->ofs);
 	switch (key->type & ~DEF_SAVEGLOBAL)
 	{
 	case ev_string:
@@ -931,7 +1000,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 		val->string = PRVM_AllocString(l, &new_p);
 		for (i = 0;i < l;i++)
 		{
-			if (s[i] == '\\' && i < l-1)
+			if (s[i] == '\\' && s[i+1] && parsebackslash)
 			{
 				i++;
 				if (s[i] == 'n')
@@ -947,7 +1016,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 		break;
 
 	case ev_float:
-		while (*s && *s <= ' ')
+		while (*s && ISWHITESPACE(*s))
 			s++;
 		val->_float = atof(s);
 		break;
@@ -955,12 +1024,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;
@@ -968,21 +1037,26 @@ 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 >= prog->limit_edicts)
-			Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME);
+			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();
 		// if IncreaseEdicts was called the base pointer needs to be updated
 		if (ent)
-			val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
+			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);
@@ -1073,6 +1147,105 @@ 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 <program name> <edict number> <field> [<cvar>]\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((etype_t)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 <program name> <global> [<cvar>]\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((etype_t)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
@@ -1103,7 +1276,7 @@ void PRVM_ED_EdictSet_f(void)
 	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));
+		PRVM_ED_ParseEpair(ed, key, Cmd_Argv(4), true);
 
 	PRVM_End;
 }
@@ -1117,7 +1290,6 @@ ed should be a properly initialized empty edict.
 Used for initial level load and for savegames.
 ====================
 */
-extern cvar_t developer_entityparsing;
 const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 {
 	ddef_t *key;
@@ -1164,7 +1336,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 		}
 
 	// parse value
-		if (!COM_ParseToken_Simple(&data, false, true))
+		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);
@@ -1194,10 +1366,10 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 		{
 			char	temp[32];
 			strlcpy (temp, com_token, sizeof(temp));
-			sprintf (com_token, "0 %s 0", 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");
 	}
 
@@ -1227,6 +1399,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;
@@ -1234,6 +1407,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 	spawned = 0;
 	died = 0;
 
+	prvm_reuseedicts_always_allow = realtime;
 
 // parse ents
 	while (1)
@@ -1268,9 +1442,23 @@ 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 and a classname
 //
+		if(!ent->priv.required->free)
 		if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0)
 		{
 			string_t handle =  PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string;
@@ -1283,7 +1471,11 @@ void PRVM_ED_LoadFromFile (const char *data)
 			}
 
 			// 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)
 			{
@@ -1296,13 +1488,13 @@ 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);
 					}
 					PRVM_ED_Free (ent);
-					continue;
+					continue; // not included in "inhibited" count
 				}
 			}
 			else
@@ -1313,12 +1505,22 @@ void PRVM_ED_LoadFromFile (const char *data)
 			}
 		}
 
+		if(!ent->priv.required->free)
+		if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
+		{
+			// self = ent
+			PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
+			PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
+		}
+
 		spawned++;
 		if (ent->priv.required->free)
 			died++;
 	}
 
 	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)
@@ -1331,6 +1533,7 @@ void PRVM_FindOffsets(void)
 
 	// 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");
@@ -1359,7 +1562,9 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1372,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");
@@ -1381,10 +1587,15 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1392,15 +1603,20 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1410,6 +1626,8 @@ void PRVM_FindOffsets(void)
 	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");
@@ -1417,8 +1635,43 @@ void PRVM_FindOffsets(void)
 	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->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");
 	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");
@@ -1431,40 +1684,66 @@ void PRVM_FindOffsets(void)
 	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_OnEntityNoSpawnFunction      = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction");
-	prog->funcoffsets.GameCommand                     = PRVM_ED_FindFunctionOffset("GameCommand");
+	prog->funcoffsets.SV_Shutdown                     = PRVM_ED_FindFunctionOffset("SV_Shutdown");
+	prog->funcoffsets.URI_Get_Callback                = PRVM_ED_FindFunctionOffset("URI_Get_Callback");
 	prog->globaloffsets.SV_InitCmd                    = PRVM_ED_FindGlobalOffset("SV_InitCmd");
+	prog->globaloffsets.coop                          = PRVM_ED_FindGlobalOffset("coop");
+	prog->globaloffsets.deathmatch                    = PRVM_ED_FindGlobalOffset("deathmatch");
+	prog->globaloffsets.dmg_origin                    = PRVM_ED_FindGlobalOffset("dmg_origin");
+	prog->globaloffsets.dmg_save                      = PRVM_ED_FindGlobalOffset("dmg_save");
+	prog->globaloffsets.dmg_take                      = PRVM_ED_FindGlobalOffset("dmg_take");
+	prog->globaloffsets.drawfont                      = PRVM_ED_FindGlobalOffset("drawfont");
+	prog->globaloffsets.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.v_forward                     = PRVM_ED_FindGlobalOffset("v_forward");
-	prog->globaloffsets.v_right                       = PRVM_ED_FindGlobalOffset("v_right");
-	prog->globaloffsets.v_up                          = PRVM_ED_FindGlobalOffset("v_up");
-	prog->globaloffsets.view_angles                   = PRVM_ED_FindGlobalOffset("view_angles");
 	prog->globaloffsets.trace_allsolid                = PRVM_ED_FindGlobalOffset("trace_allsolid");
-	prog->globaloffsets.trace_startsolid              = PRVM_ED_FindGlobalOffset("trace_startsolid");
-	prog->globaloffsets.trace_fraction                = PRVM_ED_FindGlobalOffset("trace_fraction");
-	prog->globaloffsets.trace_inwater                 = PRVM_ED_FindGlobalOffset("trace_inwater");
-	prog->globaloffsets.trace_inopen                  = PRVM_ED_FindGlobalOffset("trace_inopen");
-	prog->globaloffsets.trace_endpos                  = PRVM_ED_FindGlobalOffset("trace_endpos");
-	prog->globaloffsets.trace_plane_normal            = PRVM_ED_FindGlobalOffset("trace_plane_normal");
-	prog->globaloffsets.trace_plane_dist              = PRVM_ED_FindGlobalOffset("trace_plane_dist");
-	prog->globaloffsets.trace_ent                     = PRVM_ED_FindGlobalOffset("trace_ent");
 	prog->globaloffsets.trace_dphitcontents           = PRVM_ED_FindGlobalOffset("trace_dphitcontents");
 	prog->globaloffsets.trace_dphitq3surfaceflags     = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags");
 	prog->globaloffsets.trace_dphittexturename        = PRVM_ED_FindGlobalOffset("trace_dphittexturename");
 	prog->globaloffsets.trace_dpstartcontents         = PRVM_ED_FindGlobalOffset("trace_dpstartcontents");
-	prog->globaloffsets.intermission                  = PRVM_ED_FindGlobalOffset("intermission");
-	prog->globaloffsets.coop                          = PRVM_ED_FindGlobalOffset("coop");
-	prog->globaloffsets.deathmatch                    = PRVM_ED_FindGlobalOffset("deathmatch");
-	prog->globaloffsets.dmg_take                      = PRVM_ED_FindGlobalOffset("dmg_take");
-	prog->globaloffsets.dmg_save                      = PRVM_ED_FindGlobalOffset("dmg_save");
-	prog->globaloffsets.dmg_origin                    = PRVM_ED_FindGlobalOffset("dmg_origin");
-	prog->globaloffsets.sb_showscores                 = PRVM_ED_FindGlobalOffset("sb_showscores");
-	prog->globaloffsets.drawfont                      = PRVM_ED_FindGlobalOffset("drawfont");
+	prog->globaloffsets.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.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");
@@ -1473,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
@@ -1497,10 +1777,255 @@ PRVM_ResetProg
 ===============
 */
 
-void 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();
 }
@@ -1557,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;
@@ -1572,6 +2097,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 	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
 
 	Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024));
 
@@ -1583,8 +2109,8 @@ 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->headercrc)
-		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);
@@ -1599,6 +2125,8 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 	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,
@@ -1611,8 +2139,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
 	prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof(*prog->statement_profile));
 
-	// moved edict_size calculation down below field adding code
-
 	//pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
 	prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals);
 
@@ -1635,6 +2161,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 ; i<prog->progs->numglobaldefs ; i++)
@@ -1642,6 +2171,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
@@ -1652,6 +2182,7 @@ 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 required fields
@@ -1660,12 +2191,14 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		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
 			prog->progs->entityfields++;
 		prog->progs->numfielddefs++;
 	}
+	prog->entityfields = prog->progs->entityfields;
 
 	// check required functions
 	for(i=0 ; i < numrequiredfunc ; i++)
@@ -1680,11 +2213,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 	for (i=0 ; i<prog->progs->numglobals ; i++)
 		((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
 
-	// moved edict_size calculation down here, below field adding code
-	// LordHavoc: this no longer includes the prvm_edict_t header
-	prog->edict_size = prog->progs->entityfields * 4;
-	prog->edictareasize = prog->edict_size * prog->limit_edicts;
-
 	// LordHavoc: bounds check anything static
 	for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
 	{
@@ -1783,11 +2311,188 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 			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(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;
+		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_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), "%.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
@@ -1844,7 +2549,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->fields.vp + 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++)
 			{
@@ -1892,7 +2597,7 @@ void PRVM_Fields_f (void)
 			strlcat(tempstring, "pointer  ", sizeof(tempstring));
 			break;
 		default:
-			sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
+			dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
 			strlcat(tempstring, tempstring2, sizeof(tempstring));
 			break;
 		}
@@ -1906,7 +2611,7 @@ void PRVM_Fields_f (void)
 		strlcat(tempstring, name, sizeof(tempstring));
 		for (j = (int)strlen(name);j < 25;j++)
 			strlcat(tempstring, " ", sizeof(tempstring));
-		sprintf(tempstring2, "%5d", counts[i]);
+		dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]);
 		strlcat(tempstring, tempstring2, sizeof(tempstring));
 		strlcat(tempstring, "\n", sizeof(tempstring));
 		if (strlen(tempstring) >= sizeof(tempstring)/2)
@@ -2016,7 +2721,7 @@ void PRVM_GlobalSet_f(void)
 	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) );
+		PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3), true );
 	PRVM_End;
 }
 
@@ -2031,23 +2736,33 @@ void PRVM_Init (void)
 	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");
-	// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
-#ifdef PRVM_BOUNDSCHECK_CVAR
-	Cvar_RegisterVariable (&prvm_boundscheck);
-#endif
+
+	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);
+	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();
 }
@@ -2059,6 +2774,8 @@ 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",prognr);
 
@@ -2069,18 +2786,20 @@ void PRVM_InitProg(int prognr)
 
 	memset(prog, 0, sizeof(prvm_prog_t));
 	prog->starttime = Sys_DoubleTime();
+	prog->id = ++progid;
 
 	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, buffersize, filename, fileline);
+	return _Mem_Alloc(prog->progs_mempool, NULL, buffersize, 16, filename, fileline);
 }
 
 void _PRVM_Free(void *buffer, const char *filename, int fileline)
@@ -2097,104 +2816,51 @@ void _PRVM_FreeAll(const char *filename, int 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, const char *filename, int fileline)
 {
 	PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline);
-	return NULL;
-}
-
-/*
-int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
-{
-	PRVM_ERROR ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
 	return 0;
 }
 
-int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
-{
-	int n;
-	n = e - prog->edicts;
-	if ((unsigned int)n >= prog->limit_edicts)
-		Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
-	return n;
-}
-
-//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
-//{
-//	return e - prog->edicts;
-//}
-
-//#define	PRVM_EDICT_TO_PROG(e) ((unsigned char *)(((prvm_edict_t *)e)->v) - (unsigned char *)(prog->edictsfields))
-//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
-int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
-{
-	int n;
-	n = e - prog->edicts;
-	if ((unsigned int)n >= (unsigned int)prog->max_edicts)
-		Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)", e, n, prog->edicts);
-	return n;// EXPERIMENTAL
-	//return (unsigned char *)e->v - (unsigned char *)prog->edictsfields;
-}
-prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
-{
-	if ((unsigned int)n >= (unsigned int)prog->max_edicts)
-		Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i", n);
-	return prog->edicts + n; // EXPERIMENTAL
-	//return prog->edicts + ((n) / (progs->entityfields * 4));
-}
-*/
-
-
 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))
+		// allocated string
+		num = num - PRVM_KNOWNSTRINGBASE;
+		if (num >= 0 && num < prog->numknownstrings)
 		{
-			// special range reserved for tempstrings
-			num -= (1<<30);
-			if (num < vm_tempstringsbuf.cursize)
-				return (char *)vm_tempstringsbuf.data + num;
-			else
+			if (!prog->knownstrings[num])
 			{
-				VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
+				VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
 				return "";
 			}
-		}
-		else
-#endif
-		if (num < prog->numknownstrings)
-		{
-			if (!prog->knownstrings[num])
-				VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
 			return prog->knownstrings[num];
 		}
 		else
@@ -2203,6 +2869,23 @@ 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 = 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 PRVM_SetEngineString(const char *s)
@@ -2217,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;
@@ -2236,20 +2917,28 @@ int PRVM_SetEngineString(const char *s)
 		{
 			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;
-	return -1 - i;
+	prog->knownstrings_freeable[i] = false;
+	if(prog->leaktest_active)
+		prog->knownstrings_origin[i] = NULL;
+	return PRVM_KNOWNSTRINGBASE + i;
 }
 
 // temp string handling
@@ -2268,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;
@@ -2280,9 +2969,8 @@ 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);
-			vm_tempstringsbuf.data = Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
+			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)
@@ -2309,23 +2997,36 @@ int PRVM_AllocString(size_t bufferlength, char **pointer)
 		{
 			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 -1 - i;
+	return PRVM_KNOWNSTRINGBASE + i;
 }
 
 void PRVM_FreeString(int num)
@@ -2334,14 +3035,17 @@ 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[num])
+		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);
@@ -2350,3 +3054,250 @@ void PRVM_FreeString(int num)
 		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; i<prog->progs->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; i<prog->progs->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(PRVM_KNOWNSTRINGBASE + 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");
+}