X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=prvm_edict.c;h=1dec266c4363d3fba4b52455a9f21e0a3a45fb3c;hb=9b3cd876af961fe5d7ba30d63da0420277ba1e67;hp=9ba389a7b9f84d5faed5dfe3e4edc995c48bef68;hpb=8a12613ca05c0ceb6420751690abf2563b31f333;p=xonotic%2Fdarkplaces.git

diff --git a/prvm_edict.c b/prvm_edict.c
index 9ba389a7..1dec266c 100644
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -17,9 +17,10 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 */
-// AK new vm 
+// AK new vm
 
 #include "quakedef.h"
+#include "progsvm.h"
 
 prvm_prog_t *prog;
 
@@ -35,9 +36,6 @@ cvar_t	prvm_boundscheck = {0, "prvm_boundscheck", "1"};
 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
 cvar_t	prvm_traceqc = {0, "prvm_traceqc", "0"};
 
-ddef_t *PRVM_ED_FindField (const char *name);
-mfunction_t *PRVM_ED_FindFunction (const char *name);
-
 //============================================================================
 // mempool handling
 
@@ -46,30 +44,32 @@ mfunction_t *PRVM_ED_FindFunction (const char *name);
 PRVM_MEM_Alloc
 ===============
 */
-void PRVM_MEM_Alloc()
+void PRVM_MEM_Alloc(void)
 {
 	int i;
 
+	// reserve space for the null entity aka world
 	// check bound of max_edicts
-	prog->max_edicts = min(prog->max_edicts,prog->limit_edicts);
+	prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts);
+	prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts);
 
 	// edictprivate_size has to be min as big prvm_edict_private_t
-	prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t)); 
+	prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t));
 
 	// alloc edicts
-	prog->edicts = Mem_Alloc(prog->edicts_mempool,prog->limit_edicts * sizeof(prvm_edict_t));
-	
+	prog->edicts = (prvm_edict_t *)Mem_Alloc(prog->progs_mempool,prog->limit_edicts * sizeof(prvm_edict_t));
+
 	// alloc edict private space
-	prog->edictprivate = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edictprivate_size);
-	
+	prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
+
 	// alloc edict fields
-	prog->edictsfields = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edict_size);
+	prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
 
 	// set edict pointers
 	for(i = 0; i < prog->max_edicts; i++)
 	{
-		prog->edicts[i].e = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
+		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
 	}
 }
 
@@ -78,23 +78,23 @@ void PRVM_MEM_Alloc()
 PRVM_MEM_IncreaseEdicts
 ===============
 */
-void PRVM_MEM_IncreaseEdicts()
+void PRVM_MEM_IncreaseEdicts(void)
 {
 	int		i;
-	int		oldmaxedicts = prog->max_edicts; 
+	int		oldmaxedicts = prog->max_edicts;
 	void	*oldedictsfields = prog->edictsfields;
 	void	*oldedictprivate = prog->edictprivate;
-	
+
 	if(prog->max_edicts >= prog->limit_edicts)
 		return;
-	
+
 	PRVM_GCALL(begin_increase_edicts)();
 
 	// increase edicts
 	prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
 
-	prog->edictsfields = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edict_size);
-	prog->edictprivate = Mem_Alloc(prog->edicts_mempool, prog->max_edicts * prog->edictprivate_size);
+	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);
@@ -102,8 +102,8 @@ void PRVM_MEM_IncreaseEdicts()
 	//set e and v pointers
 	for(i = 0; i < prog->max_edicts; i++)
 	{
-		prog->edicts[i].e = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].priv.required  = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
+		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
 	}
 
 	PRVM_GCALL(end_increase_edicts)();
@@ -167,15 +167,15 @@ PRVM_SetProg
 */
 void PRVM_SetProg(int prognr)
 {
-	if(prognr && prognr < PRVM_MAXPROGS)
-	{	
+	if(0 <= prognr && prognr < PRVM_MAXPROGS)
+	{
 		if(prog_list[prognr].loaded)
 			prog = &prog_list[prognr];
 		else
-			PRVM_ERROR("%i(%s) not loaded !\n", prognr, PRVM_NAME);
+			PRVM_ERROR("%i not loaded !", prognr);
 		return;
 	}
-	PRVM_ERROR("Invalid program number %i\n", prognr);
+	PRVM_ERROR("Invalid program number %i", prognr);
 }
 
 /*
@@ -187,14 +187,11 @@ Sets everything to NULL
 */
 void PRVM_ED_ClearEdict (prvm_edict_t *e)
 {
-	int num;
-	memset (e->v, 0, prog->progs->entityfields * 4);
-	e->e->free = false;
-	// LordHavoc: for consistency set these here
-	num = PRVM_NUM_FOR_EDICT(e) - 1;
+	memset (e->fields.vp, 0, prog->progs->entityfields * 4);
+	e->priv.required->free = false;
 
 	// AK: Let the init_edict function determine if something needs to be initialized
-	PRVM_GCALL(init_edict)(num);	
+	PRVM_GCALL(init_edict)(e);
 }
 
 /*
@@ -216,21 +213,21 @@ prvm_edict_t *PRVM_ED_Alloc (void)
 	// the client qc dont need maxclients
 	// thus it doesnt need to use svs.maxclients
 	// AK:	changed i=svs.maxclients+1
-	// AK:	changed so the edict 0 wont spawned -> used as reserved/world entity
+	// AK:	changed so the edict 0 wont spawn -> used as reserved/world entity
 	//		although the menu/client has no world
-	for (i = 1;i < prog->num_edicts;i++)
+	for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++)
 	{
 		e = PRVM_EDICT_NUM(i);
 		// the first couple seconds of server time can involve a lot of
 		// freeing and allocating, so relax the replacement policy
-		if (e->e->free && ( e->e->freetime < 2 || prog->time - e->e->freetime > 0.5 ) )
+		if (e->priv.required->free && ( e->priv.required->freetime < 2 || (*prog->time - e->priv.required->freetime) > 0.5 ) )
 		{
 			PRVM_ED_ClearEdict (e);
 			return e;
 		}
 	}
 
-	if (i == MAX_EDICTS)
+	if (i == prog->limit_edicts)
 		PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME);
 
 	prog->num_edicts++;
@@ -253,10 +250,14 @@ FIXME: walk all entities and NULL out references to this entity
 */
 void PRVM_ED_Free (prvm_edict_t *ed)
 {
+	// dont delete the null entity (world) or reserved edicts
+	if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
+		return;
+
 	PRVM_GCALL(free_edict)(ed);
 
-	ed->e->free = true;
-	ed->e->freetime = prog->time;
+	ed->priv.required->free = true;
+	ed->priv.required->freetime = *prog->time;
 }
 
 //===========================================================================
@@ -367,21 +368,21 @@ Returns a string describing *data in a type specific manner
 */
 char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
 {
-	static char line[1024]; // LordHavoc: enlarged a bit (was 256)
+	static char line[MAX_INPUTLINE];
 	ddef_t *def;
 	mfunction_t *f;
 	int n;
 
-	type &= ~DEF_SAVEGLOBAL;
+	type = (etype_t)((int) type & ~DEF_SAVEGLOBAL);
 
 	switch (type)
 	{
 	case ev_string:
-		sprintf (line, "%s", PRVM_GetString(val->string));
+		strlcpy (line, PRVM_GetString (val->string), sizeof (line));
 		break;
 	case ev_entity:
 		n = val->edict;
-		if (n < 0 || n >= MAX_EDICTS)
+		if (n < 0 || n >= prog->limit_edicts)
 			sprintf (line, "entity %i (invalid!)", n);
 		else
 			sprintf (line, "entity %i", n);
@@ -426,14 +427,14 @@ Easier to parse than PR_ValueString
 */
 char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
 {
-	static char line[4096];
+	static char line[MAX_INPUTLINE];
 	int i;
-	char *s;
+	const char *s;
 	ddef_t *def;
 	mfunction_t *f;
-	
-	type &= ~DEF_SAVEGLOBAL;
-	
+
+	type = (etype_t)((int)type & ~DEF_SAVEGLOBAL);
+
 	switch (type)
 	{
 	case ev_string:
@@ -460,30 +461,30 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
 		line[i] = '\0';
 		break;
 	case ev_entity:
-		snprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
+		dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
 		break;
 	case ev_function:
-		f = pr_functions + val->function;
-		snprintf (line, sizeof (line), "%s", PRVM_GetString(f->s_name));
+		f = prog->functions + val->function;
+		strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
 		break;
 	case ev_field:
 		def = PRVM_ED_FieldAtOfs ( val->_int );
-		snprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
+		dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
 		break;
 	case ev_void:
-		snprintf (line, sizeof (line), "void");
+		dpsnprintf (line, sizeof (line), "void");
 		break;
 	case ev_float:
-		snprintf (line, sizeof (line), "%f", val->_float);
+		dpsnprintf (line, sizeof (line), "%f", val->_float);
 		break;
 	case ev_vector:
-		snprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
+		dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
 		break;
 	default:
-		snprintf (line, sizeof (line), "bad type %i", type);
+		dpsnprintf (line, sizeof (line), "bad type %i", type);
 		break;
 	}
-	
+
 	return line;
 }
 
@@ -498,18 +499,18 @@ padded to 20 field width
 char *PRVM_GlobalString (int ofs)
 {
 	char	*s;
-	int		i;
+	size_t	i;
 	ddef_t	*def;
 	void	*val;
 	static char	line[128];
 
-	val = (void *)&prog->globals[ofs];
+	val = (void *)&prog->globals.generic[ofs];
 	def = PRVM_ED_GlobalAtOfs(ofs);
 	if (!def)
 		sprintf (line,"%i(?)", ofs);
 	else
 	{
-		s = PRVM_ValueString (def->type, val);
+		s = PRVM_ValueString ((etype_t)def->type, (prvm_eval_t *)val);
 		sprintf (line,"%i(%s)%s", ofs, PRVM_GetString(def->s_name), s);
 	}
 
@@ -523,7 +524,7 @@ char *PRVM_GlobalString (int ofs)
 
 char *PRVM_GlobalStringNoContents (int ofs)
 {
-	int		i;
+	size_t	i;
 	ddef_t	*def;
 	static char	line[128];
 
@@ -551,19 +552,19 @@ For debugging
 */
 // LordHavoc: optimized this to print out much more quickly (tempstring)
 // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
-void PRVM_ED_Print (prvm_edict_t *ed)
+void PRVM_ED_Print(prvm_edict_t *ed)
 {
-	int		l;
+	size_t	l;
 	ddef_t	*d;
 	int		*v;
 	int		i, j;
-	char	*name;
+	const char	*name;
 	int		type;
-	char	tempstring[8192], tempstring2[260]; // temporary string buffers
+	char	tempstring[MAX_INPUTLINE], tempstring2[260]; // temporary string buffers
 
-	if (ed->e->free)
+	if (ed->priv.required->free)
 	{
-		Con_Printf ("%s: FREE\n",PRVM_NAME);
+		Con_Printf("%s: FREE\n",PRVM_NAME);
 		return;
 	}
 
@@ -576,7 +577,7 @@ void PRVM_ED_Print (prvm_edict_t *ed)
 		if (name[strlen(name)-2] == '_')
 			continue;	// skip _x, _y, _z vars
 
-		v = (int *)((char *)ed->v + d->ofs*4);
+		v = (int *)((char *)ed->fields.vp + d->ofs*4);
 
 	// if the value is still all 0, skip the field
 		type = d->type & ~DEF_SAVEGLOBAL;
@@ -587,11 +588,11 @@ void PRVM_ED_Print (prvm_edict_t *ed)
 		if (j == prvm_type_size[type])
 			continue;
 
-		if (strlen(name) > 256)
+		if (strlen(name) > sizeof(tempstring2)-4)
 		{
-			strncpy(tempstring2, name, 256);
-			tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
-			tempstring2[259] = 0;
+			memcpy (tempstring2, name, sizeof(tempstring2)-4);
+			tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
+			tempstring2[sizeof(tempstring2)-1] = 0;
 			name = tempstring2;
 		}
 		strcat(tempstring, name);
@@ -599,24 +600,24 @@ void PRVM_ED_Print (prvm_edict_t *ed)
 			strcat(tempstring, " ");
 		strcat(tempstring, " ");
 
-		name = PRVM_ValueString(d->type, (prvm_eval_t *)v);
-		if (strlen(name) > 256)
+		name = PRVM_ValueString((etype_t)d->type, (prvm_eval_t *)v);
+		if (strlen(name) > sizeof(tempstring2)-4)
 		{
-			strncpy(tempstring2, name, 256);
-			tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
-			tempstring2[259] = 0;
+			memcpy (tempstring2, name, sizeof(tempstring2)-4);
+			tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
+			tempstring2[sizeof(tempstring2)-1] = 0;
 			name = tempstring2;
 		}
 		strcat(tempstring, name);
 		strcat(tempstring, "\n");
-		if (strlen(tempstring) >= 4096)
+		if (strlen(tempstring) >= sizeof(tempstring)/2)
 		{
-			Con_Printf("%s", tempstring);
+			Con_Print(tempstring);
 			tempstring[0] = 0;
 		}
 	}
 	if (tempstring[0])
-		Con_Printf("%s", tempstring);
+		Con_Print(tempstring);
 }
 
 /*
@@ -631,14 +632,14 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 	ddef_t	*d;
 	int		*v;
 	int		i, j;
-	char	*name;
+	const char	*name;
 	int		type;
 
-	FS_Printf (f, "{\n");
+	FS_Print(f, "{\n");
 
-	if (ed->e->free)
+	if (ed->priv.required->free)
 	{
-		FS_Printf (f, "}\n");
+		FS_Print(f, "}\n");
 		return;
 	}
 
@@ -649,7 +650,7 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 		if (name[strlen(name)-2] == '_')
 			continue;	// skip _x, _y, _z vars
 
-		v = (int *)((char *)ed->v + d->ofs*4);
+		v = (int *)((char *)ed->fields.vp + d->ofs*4);
 
 	// if the value is still all 0, skip the field
 		type = d->type & ~DEF_SAVEGLOBAL;
@@ -659,16 +660,16 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 		if (j == prvm_type_size[type])
 			continue;
 
-		FS_Printf (f,"\"%s\" ",name);
-		FS_Printf (f,"\"%s\"\n", PRVM_UglyValueString(d->type, (prvm_eval_t *)v));
+		FS_Printf(f,"\"%s\" ",name);
+		FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
 	}
 
-	FS_Printf (f, "}\n");
+	FS_Print(f, "}\n");
 }
 
 void PRVM_ED_PrintNum (int ent)
 {
-	PRVM_ED_Print (PRVM_EDICT_NUM(ent));
+	PRVM_ED_Print(PRVM_EDICT_NUM(ent));
 }
 
 /*
@@ -687,12 +688,12 @@ void PRVM_ED_PrintEdicts_f (void)
 		Con_Print("prvm_edicts <program name>\n");
 		return;
 	}
-	
+
 	PRVM_Begin;
 	if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 		return;
 
-	Con_Printf ("%s: %i entities\n", PRVM_NAME, prog->num_edicts);
+	Con_Printf("%s: %i entities\n", PRVM_NAME, prog->num_edicts);
 	for (i=0 ; i<prog->num_edicts ; i++)
 		PRVM_ED_PrintNum (i);
 
@@ -723,7 +724,8 @@ void PRVM_ED_PrintEdict_f (void)
 	i = atoi (Cmd_Argv(2));
 	if (i >= prog->num_edicts)
 	{
-		Con_Printf("Bad edict number\n");
+		Con_Print("Bad edict number\n");
+		PRVM_End;
 		return;
 	}
 	PRVM_ED_PrintNum (i);
@@ -764,13 +766,13 @@ void PRVM_ED_Count_f (void)
 		for (i=0 ; i<prog->num_edicts ; i++)
 		{
 			ent = PRVM_EDICT_NUM(i);
-			if (ent->e->free)
+			if (ent->priv.required->free)
 				continue;
 			active++;
 		}
-		
-		Con_Printf ("num_edicts:%3i\n", sv.num_edicts);
-		Con_Printf ("active    :%3i\n", active);
+
+		Con_Printf("num_edicts:%3i\n", prog->num_edicts);
+		Con_Printf("active    :%3i\n", active);
 	}
 
 	PRVM_End;
@@ -794,10 +796,10 @@ void PRVM_ED_WriteGlobals (qfile_t *f)
 {
 	ddef_t		*def;
 	int			i;
-	char		*name;
+	const char		*name;
 	int			type;
 
-	FS_Printf (f,"{\n");
+	FS_Print(f,"{\n");
 	for (i=0 ; i<prog->progs->numglobaldefs ; i++)
 	{
 		def = &prog->globaldefs[i];
@@ -810,10 +812,10 @@ void PRVM_ED_WriteGlobals (qfile_t *f)
 			continue;
 
 		name = PRVM_GetString(def->s_name);
-		FS_Printf (f,"\"%s\" ", name);
-		FS_Printf (f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals[def->ofs]));
+		FS_Printf(f,"\"%s\" ", name);
+		FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
 	}
-	FS_Printf (f,"}\n");
+	FS_Print(f,"}\n");
 }
 
 /*
@@ -823,14 +825,14 @@ PRVM_ED_ParseGlobals
 */
 void PRVM_ED_ParseGlobals (const char *data)
 {
-	char keyname[1024]; // LordHavoc: good idea? bad idea?  was 64
+	char keyname[MAX_INPUTLINE];
 	ddef_t *key;
 
 	while (1)
 	{
 		// parse key
 		if (!COM_ParseToken(&data, false))
-			PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
+			PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
 		if (com_token[0] == '}')
 			break;
 
@@ -838,15 +840,15 @@ void PRVM_ED_ParseGlobals (const char *data)
 
 		// parse value
 		if (!COM_ParseToken(&data, false))
-			PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
+			PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
 
 		if (com_token[0] == '}')
-			PRVM_ERROR ("PRVM_ED_ParseEntity: closing brace without data");
+			PRVM_ERROR ("PRVM_ED_ParseGlobals: closing brace without data");
 
 		key = PRVM_ED_FindGlobal (keyname);
 		if (!key)
 		{
-			Con_DPrintf ("'%s' is not a global on %s\n", keyname, PRVM_NAME);
+			Con_DPrintf("'%s' is not a global on %s\n", keyname, PRVM_NAME);
 			continue;
 		}
 
@@ -858,38 +860,6 @@ void PRVM_ED_ParseGlobals (const char *data)
 //============================================================================
 
 
-/*
-=============
-PRVM_ED_NewString
-=============
-*/
-char *PRVM_ED_NewString (const char *string)
-{
-	char *new, *new_p;
-	int i,l;
-
-	l = strlen(string) + 1;
-	new = Mem_Alloc(prog->edictstring_mempool, l);
-	new_p = new;
-
-	for (i=0 ; i< l ; i++)
-	{
-		if (string[i] == '\\' && i < l-1)
-		{
-			i++;
-			if (string[i] == 'n')
-				*new_p++ = '\n';
-			else
-				*new_p++ = '\\';
-		}
-		else
-			*new_p++ = string[i];
-	}
-
-	return new;
-}
-
-
 /*
 =============
 PRVM_ED_ParseEval
@@ -900,19 +870,36 @@ returns false if error
 */
 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 {
-	int i;
+	int i, l;
+	char *new_p;
 	ddef_t *def;
 	prvm_eval_t *val;
 	mfunction_t *func;
 
 	if (ent)
-		val = (prvm_eval_t *)((int *)ent->v + key->ofs);
+		val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
 	else
-		val = (prvm_eval_t *)((int *)pr_globals + key->ofs);
+		val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs);
 	switch (key->type & ~DEF_SAVEGLOBAL)
 	{
 	case ev_string:
-		val->string = PRVM_SetString(ED_NewString(s));
+		l = (int)strlen(s) + 1;
+		val->string = PRVM_AllocString(l, &new_p);
+		for (i = 0;i < l;i++)
+		{
+			if (s[i] == '\\' && i < l-1)
+			{
+				i++;
+				if (s[i] == 'n')
+					*new_p++ = '\n';
+				else if (s[i] == 'r')
+					*new_p++ = '\r';
+				else
+					*new_p++ = s[i];
+			}
+			else
+				*new_p++ = s[i];
+		}
 		break;
 
 	case ev_float:
@@ -940,44 +927,79 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 		while (*s && *s <= ' ')
 			s++;
 		i = atoi(s);
-		if (i < 0 || i >= MAX_EDICTS)
-			Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME);
+		if (i >= prog->limit_edicts)
+			Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME);
 		while (i >= prog->max_edicts)
 			PRVM_MEM_IncreaseEdicts();
 			//SV_IncreaseEdicts();
 		// if SV_IncreaseEdicts was called the base pointer needs to be updated
 		if (ent)
-			val = (prvm_eval_t *)((int *)ent->v + key->ofs);
-		val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i));
+			val = (prvm_eval_t *)((int *)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 (!def)
 		{
-			Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s on %s\n", s, PRVM_NAME);
+			Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s in %s\n", s, PRVM_NAME);
 			return false;
 		}
-		val->_int = PRVM_G_INT(def->ofs);
+		val->_int = def->ofs;
 		break;
 
 	case ev_function:
 		func = PRVM_ED_FindFunction(s);
 		if (!func)
 		{
-			Con_Printf ("PRVM_ED_ParseEpair: Can't find function %s on %s\n", s, PRVM_NAME);
+			Con_Printf("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, PRVM_NAME);
 			return false;
 		}
 		val->function = func - prog->functions;
 		break;
 
 	default:
-		Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PR_GetString(key->s_name), PRVM_NAME);
+		Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME);
 		return false;
 	}
 	return true;
 }
 
+/*
+=============
+PRVM_ED_EdictSet_f
+
+Console command to set a field of a specified edict
+=============
+*/
+void PRVM_ED_EdictSet_f(void)
+{
+	prvm_edict_t *ed;
+	ddef_t *key;
+
+	if(Cmd_Argc() != 5)
+	{
+		Con_Print("prvm_edictset <program name> <edict number> <field> <value>\n");
+		return;
+	}
+
+	PRVM_Begin;
+	if(!PRVM_SetProgFromString(Cmd_Argv(1)))
+	{
+		Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
+		return;
+	}
+
+	ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
+
+	if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0)
+		Con_Printf("Key %s not found !\n", Cmd_Argv(3));
+	else
+		PRVM_ED_ParseEpair(ed, key, Cmd_Argv(4));
+
+	PRVM_End;
+}
+
 /*
 ====================
 PRVM_ED_ParseEdict
@@ -987,26 +1009,25 @@ 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;
 	qboolean anglehack;
 	qboolean init;
 	char keyname[256];
-	int n;
+	size_t n;
 
 	init = false;
 
-// clear it
-	if (ent != prog->edicts)	// hack
-		memset (ent->v, 0, prog->progs->entityfields * 4);
-
 // go through all the dictionary pairs
 	while (1)
 	{
 	// parse key
 		if (!COM_ParseToken(&data, false))
-			PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
+			PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace");
+		if (developer_entityparsing.integer)
+			Con_Printf("Key: \"%s\"", com_token);
 		if (com_token[0] == '}')
 			break;
 
@@ -1026,7 +1047,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 
 		strcpy (keyname, com_token);
 
-		// another hack to fix heynames with trailing spaces
+		// another hack to fix keynames with trailing spaces
 		n = strlen(keyname);
 		while (n && keyname[n-1] == ' ')
 		{
@@ -1036,13 +1057,19 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 
 	// parse value
 		if (!COM_ParseToken(&data, false))
-			PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
+			PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace");
+		if (developer_entityparsing.integer)
+			Con_Printf(" \"%s\"\n", com_token);
 
 		if (com_token[0] == '}')
-			PRVM_ERROR ("PRVM_ED_ParseEntity: closing brace without data");
+			PRVM_ERROR ("PRVM_ED_ParseEdict: closing brace without data");
 
 		init = true;
 
+		// ignore attempts to set key "" (this problem occurs in nehahra neh1m8.bsp)
+		if (!keyname[0])
+			continue;
+
 // keynames with a leading underscore are used for utility comments,
 // and are immediately discarded by quake
 		if (keyname[0] == '_')
@@ -1051,7 +1078,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 		key = PRVM_ED_FindField (keyname);
 		if (!key)
 		{
-			Con_DPrintf ("%s: '%s' is not a field\n", PRVM_NAME, keyname);
+			Con_DPrintf("%s: '%s' is not a field\n", PRVM_NAME, keyname);
 			continue;
 		}
 
@@ -1067,7 +1094,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
 	}
 
 	if (!init)
-		ent->e->free = true;
+		ent->priv.required->free = true;
 
 	return data;
 }
@@ -1094,16 +1121,12 @@ void PRVM_ED_LoadFromFile (const char *data)
 	int parsed, inhibited, spawned, died;
 	mfunction_t *func;
 
-	ent = NULL;
 	parsed = 0;
 	inhibited = 0;
 	spawned = 0;
 	died = 0;
 
-	// time defined ?
-	if(prog->flag & PRVM_GE_TIME)
-		PRVM_G_FLOAT(PRVM_ED_FindFieldOffset("time")) = prog->time;
-	
+
 // parse ents
 	while (1)
 	{
@@ -1111,12 +1134,21 @@ void PRVM_ED_LoadFromFile (const char *data)
 		if (!COM_ParseToken(&data, false))
 			break;
 		if (com_token[0] != '{')
-			PRVM_ERROR ("PRVM_ED_LoadFromFile: found %s when expecting (%s) {",com_token, PRVM_NAME);
+			PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token);
 
-		if (!ent)
+		// CHANGED: this is not conform to PR_LoadFromFile
+		if(prog->loadintoworld)
+		{
+			prog->loadintoworld = false;
 			ent = PRVM_EDICT_NUM(0);
+		}
 		else
-			ent = PRVM_ED_Alloc ();
+			ent = PRVM_ED_Alloc();
+
+		// clear it
+		if (ent != prog->edicts)	// hack
+			memset (ent->fields.vp, 0, prog->progs->entityfields * 4);
+
 		data = PRVM_ED_ParseEdict (data, ent);
 		parsed++;
 
@@ -1129,44 +1161,44 @@ void PRVM_ED_LoadFromFile (const char *data)
 		}
 
 //
-// immediately call spawn function, but only if there is a self global
+// immediately call spawn function, but only if there is a self global and a classname
 //
 		if(prog->self && prog->flag & PRVM_FE_CLASSNAME)
 		{
-			string_t handle =  *(string_t*)&((float*)ent->v)[PRVM_ED_FindFieldOffset("classname")];
+			string_t handle =  *(string_t*)&((unsigned char*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")];
 			if (!handle)
 			{
-				Con_Printf ("No classname for:\n");
-				PRVM_ED_Print (ent);
+				Con_Print("No classname for:\n");
+				PRVM_ED_Print(ent);
 				PRVM_ED_Free (ent);
 				continue;
 			}
-			
+
 			// look for the spawn function
 			func = PRVM_ED_FindFunction (PRVM_GetString(handle));
-			
+
 			if (!func)
 			{
 				if (developer.integer) // don't confuse non-developers with errors
 				{
-					Con_Printf ("No spawn function for:\n");
-					PRVM_ED_Print (ent);
+					Con_Print("No spawn function for:\n");
+					PRVM_ED_Print(ent);
 				}
 				PRVM_ED_Free (ent);
 				continue;
 			}
-			
+
 			// self = ent
 			PRVM_G_INT(prog->self->ofs) = PRVM_EDICT_TO_PROG(ent);
 			PRVM_ExecuteProgram (func - prog->functions, "");
 		}
-	
+
 		spawned++;
-		if (ent->e->free)
+		if (ent->priv.required->free)
 			died++;
 	}
 
-	Con_DPrintf ("%s: %i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, spawned, died, spawned - died);
+	Con_DPrintf("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died);
 }
 
 // not used
@@ -1193,24 +1225,55 @@ PRVM_ResetProg
 
 void PRVM_ResetProg()
 {
-	mempool_t *t1, *t2, *t3;
-
-	t1 = prog->progs_mempool;
-	t2 = prog->edictstring_mempool;
-	t3 = prog->edicts_mempool;
-	
-	Mem_EmptyPool(prog->progs_mempool);
-	Mem_EmptyPool(prog->edictstring_mempool);
-	Mem_EmptyPool(prog->edicts_mempool);
-	
+	PRVM_GCALL(reset_cmd)();
+	Mem_FreePool(&prog->progs_mempool);
 	memset(prog,0,sizeof(prvm_prog_t));
-	
-	
-	prog->progs_mempool = t1;
-	prog->edictstring_mempool = t2;
-	prog->edicts_mempool = t3;
+}
 
-	PRVM_GCALL(reset_cmd)();
+/*
+===============
+PRVM_LoadLNO
+===============
+*/
+void PRVM_LoadLNO( const char *progname ) {
+	fs_offset_t filesize;
+	unsigned char *lno;
+	unsigned int *header;
+	char filename[512];
+
+	FS_StripExtension( progname, filename, sizeof( filename ) );
+	strlcat( filename, ".lno", sizeof( filename ) );
+
+	lno = FS_LoadFile( filename, tempmempool, false, &filesize );
+	if( !lno ) {
+		return;
+	}
+
+/*
+<Spike>    SafeWrite (h, &lnotype, sizeof(int));
+<Spike>    SafeWrite (h, &version, sizeof(int));
+<Spike>    SafeWrite (h, &numglobaldefs, sizeof(int));
+<Spike>    SafeWrite (h, &numpr_globals, sizeof(int));
+<Spike>    SafeWrite (h, &numfielddefs, sizeof(int));
+<Spike>    SafeWrite (h, &numstatements, sizeof(int));
+<Spike>    SafeWrite (h, statement_linenums, numstatements*sizeof(int));
+*/
+	if( (unsigned) filesize < (6 + prog->progs->numstatements) * sizeof( int ) ) {
+        return;
+	}
+
+	header = (unsigned int *) lno;
+	if( header[ 0 ] == *(unsigned int *) "LNOF" &&
+		LittleLong( header[ 1 ] ) == 1 &&
+		(unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs->numglobaldefs &&
+		(unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs->numglobals &&
+		(unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs->numfielddefs &&
+		(unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs->numstatements )
+	{
+		prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof( int ) );
+		memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs->numstatements * sizeof( int ) );
+	}
+	Mem_Free( lno );
 }
 
 /*
@@ -1218,29 +1281,25 @@ void PRVM_ResetProg()
 PRVM_LoadProgs
 ===============
 */
-void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func)
+void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field)
 {
 	int i;
 	dstatement_t *st;
 	ddef_t *infielddefs;
-	void *temp;
 	dfunction_t *dfunctions;
+	fs_offset_t filesize;
 
-	Mem_EmptyPool(prog->progs_mempool);
-	Mem_EmptyPool(prog->edictstring_mempool);
+	if( prog->loaded ) {
+		PRVM_ERROR ("PRVM_LoadProgs: there is already a %s program loaded!", PRVM_NAME );
+	}
 
-	temp = FS_LoadFile (filename, false);
-	if (temp == 0)
+	prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
+	if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
 		PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME);
 
-	prog->progs = (dprograms_t *)Mem_Alloc(prog->progs_mempool, fs_filesize);
+	Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, filesize/1024);
 
-	memcpy(prog->progs, temp, fs_filesize);
-	Mem_Free(temp);
-
-	Con_DPrintf ("%s programs occupy %iK.\n", PRVM_NAME, fs_filesize/1024);
-
-	pr_crc = CRC_Block((qbyte *)prog->progs, fs_filesize);
+	prog->filecrc = CRC_Block((unsigned char *)prog->progs, filesize);
 
 // byte swap the header
 	for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++)
@@ -1248,26 +1307,39 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
 	if (prog->progs->version != PROG_VERSION)
 		PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION);
-	if (prog->progs->crc != prog->crc)
+	if (prog->progs->crc != prog->headercrc)
 		PRVM_ERROR ("%s: %s system vars have been modified, progdefs.h is out of date", PRVM_NAME, filename);
 
-	//pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
-	dfunctions = (dfunction_t *)((qbyte *)prog->progs + prog->progs->ofs_functions);
+	//prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions);
+	dfunctions = (dfunction_t *)((unsigned char *)prog->progs + prog->progs->ofs_functions);
+
 	prog->strings = (char *)prog->progs + prog->progs->ofs_strings;
-	prog->globaldefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_globaldefs);
+	prog->stringssize = 0;
+	for (i = 0;i < prog->progs->numstrings;i++)
+	{
+		if (prog->progs->ofs_strings + prog->stringssize >= (int)filesize)
+			PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename);
+		prog->stringssize += (int)strlen (prog->strings + prog->stringssize) + 1;
+	}
+	prog->numknownstrings = 0;
+	prog->maxknownstrings = 0;
+	prog->knownstrings = NULL;
+	prog->knownstrings_freeable = NULL;
+
+	prog->globaldefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_globaldefs);
 
 	// we need to expand the fielddefs list to include all the engine fields,
 	// so allocate a new place for it
-	infielddefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_fielddefs);
+	infielddefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_fielddefs);
 	//												( + DPFIELDS			   )
-	prog->fielddefs = Mem_Alloc(prog->progs_mempool, prog->progs->numfielddefs * sizeof(ddef_t));
+	prog->fielddefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t));
 
-	prog->statements = (dstatement_t *)((qbyte *)prog->progs + prog->progs->ofs_statements);
+	prog->statements = (dstatement_t *)((unsigned char *)prog->progs + prog->progs->ofs_statements);
 
 	// moved edict_size calculation down below field adding code
 
-	//pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
-	prog->globals = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals);
+	//pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
+	prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals);
 
 // byte swap the lumps
 	for (i=0 ; i<prog->progs->numstatements ; i++)
@@ -1278,7 +1350,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		prog->statements[i].c = LittleShort(prog->statements[i].c);
 	}
 
-	prog->functions = Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions);
+	prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions);
 	for (i = 0;i < prog->progs->numfunctions;i++)
 	{
 		prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
@@ -1307,31 +1379,31 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
 	}
 
-/*	// append the darkplaces fields
-	for (i = 0;i < (int) DPFIELDS;i++)
+	// append the required fields
+	for (i = 0;i < (int) numrequiredfields;i++)
 	{
-		pr_fielddefs[progs->numfielddefs].type = dpfields[i].type;
-		pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields;
-		pr_fielddefs[progs->numfielddefs].s_name = PR_SetString(dpfields[i].string);
-		if (pr_fielddefs[progs->numfielddefs].type == ev_vector)
-			progs->entityfields += 3;
+		prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
+		prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
+		prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
+		if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
+			prog->progs->entityfields += 3;
 		else
-			progs->entityfields++;
-		progs->numfielddefs++;
-	}*/
+			prog->progs->entityfields++;
+		prog->progs->numfielddefs++;
+	}
 
 	// check required functions
 	for(i=0 ; i < numrequiredfunc ; i++)
 		if(PRVM_ED_FindFunction(required_func[i]) == 0)
-			PRVM_ERROR("%s: %s not found in %s\n",PRVM_NAME, required_func[i], filename);
+			PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_func[i], filename);
 
 	for (i=0 ; i<prog->progs->numglobals ; i++)
-		((int *)prog->globals)[i] = LittleLong (((int *)prog->globals)[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 edict_t header
+	// LordHavoc: this no longer includes the prvm_edict_t header
 	prog->edict_size = prog->progs->entityfields * 4;
-	prog->edictareasize = prog->edict_size * MAX_EDICTS;
+	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++)
@@ -1341,11 +1413,11 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		case OP_IF:
 		case OP_IFNOT:
 			if ((unsigned short) st->a >= prog->progs->numglobals || st->b + i < 0 || st->b + i >= prog->progs->numstatements)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s\n", i, PRVM_NAME);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s", i, PRVM_NAME);
 			break;
 		case OP_GOTO:
 			if (st->a + i < 0 || st->a + i >= prog->progs->numstatements)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s\n", i, PRVM_NAME);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s", i, PRVM_NAME);
 			break;
 		// global global global
 		case OP_ADD_F:
@@ -1383,7 +1455,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		case OP_LOAD_FNC:
 		case OP_LOAD_V:
 			if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n", i);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)", i);
 			break;
 		// global none global
 		case OP_NOT_F:
@@ -1392,7 +1464,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		case OP_NOT_FNC:
 		case OP_NOT_ENT:
 			if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
 			break;
 		// 2 globals
 		case OP_STOREP_F:
@@ -1409,7 +1481,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		case OP_STOREP_V:
 		case OP_STORE_V:
 			if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n in %s", i, PRVM_NAME);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
 			break;
 		// 1 global
 		case OP_CALL0:
@@ -1424,38 +1496,40 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		case OP_DONE:
 		case OP_RETURN:
 			if ((unsigned short) st->a >= prog->progs->numglobals)
-				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME);
+				PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
 			break;
 		default:
-			PRVM_ERROR("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME);
+			PRVM_ERROR("PRVM_LoadProgs: unknown opcode %d at statement %d in %s", st->op, i, PRVM_NAME);
 			break;
 		}
 	}
 
+	PRVM_LoadLNO(filename);
+
 	PRVM_Init_Exec();
 
 	prog->loaded = TRUE;
-	
+
 	// set flags & ddef_ts in prog
-	
+
 	prog->flag = 0;
-	
+
 	prog->self = PRVM_ED_FindGlobal("self");
 
-	if(PRVM_ED_FindGlobal("time"))
-		prog->flag |= PRVM_GE_TIME;
+	if( PRVM_ED_FindGlobal("time") && PRVM_ED_FindGlobal("time")->type & ev_float )
+		prog->time = &PRVM_G_FLOAT(PRVM_ED_FindGlobal("time")->ofs);
 
 	if(PRVM_ED_FindField ("chain"))
 		prog->flag |= PRVM_FE_CHAIN;
 
 	if(PRVM_ED_FindField ("classname"))
-		prog->flag |= PRVM_FE_CLASSNAME; 
+		prog->flag |= PRVM_FE_CLASSNAME;
 
-	if(PRVM_ED_FindField ("nextthink") && PRVM_ED_FindField ("frame") && PRVM_ED_FindField ("think") 
-		&& prog->flag &  PRVM_GE_TIME && prog->self) 
+	if(PRVM_ED_FindField ("nextthink") && PRVM_ED_FindField ("frame") && PRVM_ED_FindField ("think")
+		&& prog->flag && prog->self)
 		prog->flag |= PRVM_OP_STATE;
-	
-	PRVM_GCALL(reset_cmd)();
+
+	PRVM_GCALL(init_cmd)();
 
 	// init mempools
 	PRVM_MEM_Alloc();
@@ -1466,7 +1540,8 @@ void PRVM_Fields_f (void)
 {
 	int i, j, ednum, used, usedamount;
 	int *counts;
-	char tempstring[5000], tempstring2[260], *name;
+	char tempstring[MAX_INPUTLINE], tempstring2[260];
+	const char *name;
 	prvm_edict_t *ed;
 	ddef_t *d;
 	int *v;
@@ -1475,7 +1550,7 @@ void PRVM_Fields_f (void)
 	/*
 	if (!sv.active)
 	{
-		Con_Printf("no progs loaded\n");
+		Con_Print("no progs loaded\n");
 		return;
 	}
 	*/
@@ -1490,11 +1565,11 @@ void PRVM_Fields_f (void)
 	if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 		return;
 
-	counts = Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int));
+	counts = (int *)Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int));
 	for (ednum = 0;ednum < prog->max_edicts;ednum++)
 	{
 		ed = PRVM_EDICT_NUM(ednum);
-		if (ed->e->free)
+		if (ed->priv.required->free)
 			continue;
 		for (i = 1;i < prog->progs->numfielddefs;i++)
 		{
@@ -1502,7 +1577,7 @@ void PRVM_Fields_f (void)
 			name = PRVM_GetString(d->s_name);
 			if (name[strlen(name)-2] == '_')
 				continue;	// skip _x, _y, _z vars
-			v = (int *)((char *)ed->v + d->ofs*4);
+			v = (int *)((char *)ed->fields.vp + d->ofs*4);
 			// if the value is still all 0, skip the field
 			for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
 			{
@@ -1554,22 +1629,22 @@ void PRVM_Fields_f (void)
 			strcat(tempstring, tempstring2);
 			break;
 		}
-		if (strlen(name) > 256)
+		if (strlen(name) > sizeof(tempstring2)-4)
 		{
-			strncpy(tempstring2, name, 256);
-			tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
-			tempstring2[259] = 0;
+			memcpy (tempstring2, name, sizeof(tempstring2)-4);
+			tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
+			tempstring2[sizeof(tempstring2)-1] = 0;
 			name = tempstring2;
 		}
 		strcat(tempstring, name);
-		for (j = strlen(name);j < 25;j++)
+		for (j = (int)strlen(name);j < 25;j++)
 			strcat(tempstring, " ");
 		sprintf(tempstring2, "%5d", counts[i]);
 		strcat(tempstring, tempstring2);
 		strcat(tempstring, "\n");
-		if (strlen(tempstring) >= 4096)
+		if (strlen(tempstring) >= sizeof(tempstring)/2)
 		{
-			Con_Printf("%s", tempstring);
+			Con_Print(tempstring);
 			tempstring[0] = 0;
 		}
 		if (counts[i])
@@ -1590,12 +1665,12 @@ void PRVM_Globals_f (void)
 	// TODO
 	/*if (!sv.active)
 	{
-		Con_Printf("no progs loaded\n");
+		Con_Print("no progs loaded\n");
 		return;
 	}*/
 	if(Cmd_Argc () != 2)
 	{
-		Con_Print ("prvm_globals <program name>\n");
+		Con_Print("prvm_globals <program name>\n");
 		return;
 	}
 
@@ -1606,12 +1681,62 @@ void PRVM_Globals_f (void)
 	Con_Printf("%s :", PRVM_NAME);
 
 	for (i = 0;i < prog->progs->numglobaldefs;i++)
-		Con_Printf("%s\n", PRVM_GetString(pr_globaldefs[i].s_name));
+		Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name));
 	Con_Printf("%i global variables, totalling %i bytes\n", prog->progs->numglobals, prog->progs->numglobals * 4);
 
 	PRVM_End;
 }
 
+/*
+===============
+PRVM_Global
+===============
+*/
+void PRVM_Global_f(void)
+{
+	ddef_t *global;
+	if( Cmd_Argc() != 3 ) {
+		Con_Printf( "prvm_global <program name> <global name>\n" );
+		return;
+	}
+
+	PRVM_Begin;
+	if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
+		return;
+
+	global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
+	if( !global )
+		Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+	else
+		Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( (etype_t)global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) );
+	PRVM_End;
+}
+
+/*
+===============
+PRVM_GlobalSet
+===============
+*/
+void PRVM_GlobalSet_f(void)
+{
+	ddef_t *global;
+	if( Cmd_Argc() != 4 ) {
+		Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
+		return;
+	}
+
+	PRVM_Begin;
+	if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
+		return;
+
+	global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
+	if( !global )
+		Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+	else
+		PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3) );
+	PRVM_End;
+}
+
 /*
 ===============
 PRVM_Init
@@ -1625,11 +1750,14 @@ void PRVM_Init (void)
 	Cmd_AddCommand ("prvm_profile", PRVM_Profile_f);
 	Cmd_AddCommand ("prvm_fields", PRVM_Fields_f);
 	Cmd_AddCommand ("prvm_globals", PRVM_Globals_f);
+	Cmd_AddCommand ("prvm_global", PRVM_Global_f);
+	Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f);
+	Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f);
 	// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
 	Cvar_RegisterVariable (&prvm_boundscheck);
 	Cvar_RegisterVariable (&prvm_traceqc);
 
-	VM_Cmd_Init();
+	//VM_Cmd_Init();
 }
 
 /*
@@ -1640,13 +1768,17 @@ PRVM_InitProg
 void PRVM_InitProg(int prognr)
 {
 	if(prognr < 0 || prognr >= PRVM_MAXPROGS)
-		Sys_Error("PRVM_InitProg: Invalid program number %i\n",prognr);
+		Sys_Error("PRVM_InitProg: Invalid program number %i",prognr);
 
 	prog = &prog_list[prognr];
 
+	if(prog->loaded)
+		PRVM_ResetProg();
+
 	memset(prog, 0, sizeof(prvm_prog_t));
 
-	PRVM_GCALL(init_cmd)();
+	prog->time = &prog->_time;
+	prog->error_cmd = Host_Error;
 }
 
 int PRVM_GetProgNr()
@@ -1654,6 +1786,24 @@ int PRVM_GetProgNr()
 	return prog - prog_list;
 }
 
+void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline)
+{
+	return _Mem_Alloc(prog->progs_mempool, buffersize, filename, fileline);
+}
+
+void _PRVM_Free(void *buffer, const char *filename, int fileline)
+{
+	_Mem_Free(buffer, filename, fileline);
+}
+
+void _PRVM_FreeAll(const char *filename, int fileline)
+{
+	prog->progs = NULL;
+	prog->fielddefs = NULL;
+	prog->functions = NULL;
+	_Mem_EmptyPool(prog->progs_mempool, filename, fileline);
+}
+
 // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
 prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline)
 {
@@ -1662,43 +1812,155 @@ prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline)
 }
 
 /*
-int NUM_FOR_EDICT_ERROR(edict_t *e)
+int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
 {
-	Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts);
+	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 NUM_FOR_EDICT(edict_t *e)
+int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
 {
 	int n;
-	n = e - sv.edicts;
-	if ((unsigned int)n >= MAX_EDICTS)
-		Host_Error ("NUM_FOR_EDICT: bad pointer");
+	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(edict_t *e)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
 //{
-//	return e - sv.edicts;
+//	return e - prog->edicts;
 //}
 
-//#define	EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields))
-//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
-int EDICT_TO_PROG(edict_t *e)
+//#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 - sv.edicts;
-	if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-		Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts);
+	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 (qbyte *)e->v - (qbyte *)sv.edictsfields;
+	//return (unsigned char *)e->v - (unsigned char *)prog->edictsfields;
 }
-edict_t *PROG_TO_EDICT(int n)
+prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
 {
-	if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-		Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
-	return sv.edicts + n; // EXPERIMENTAL
-	//return sv.edicts + ((n) / (progs->entityfields * 4));
+	if ((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));
 }
 */
 
+
+const char *PRVM_GetString(int num)
+{
+	if (num >= 0 && num < prog->stringssize)
+		return prog->strings + num;
+	else if (num < 0 && num >= -prog->numknownstrings)
+	{
+		num = -1 - num;
+		if (!prog->knownstrings[num])
+			PRVM_ERROR("PRVM_GetString: attempt to get string that is already freed");
+		return prog->knownstrings[num];
+	}
+	else
+	{
+		PRVM_ERROR("PRVM_GetString: invalid string offset %i", num);
+		return "";
+	}
+}
+
+int PRVM_SetEngineString(const char *s)
+{
+	int i;
+	if (!s)
+		return 0;
+	if (s >= prog->strings && s <= prog->strings + prog->stringssize)
+		PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area");
+	for (i = 0;i < prog->numknownstrings;i++)
+		if (prog->knownstrings[i] == s)
+			return -1 - i;
+	// new unknown engine string
+	if (developer.integer >= 3)
+		Con_Printf("new engine string %p\n", s);
+	for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
+		if (!prog->knownstrings[i])
+			break;
+	if (i >= prog->numknownstrings)
+	{
+		if (i >= prog->maxknownstrings)
+		{
+			const char **oldstrings = prog->knownstrings;
+			const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
+			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->numknownstrings)
+			{
+				memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
+				memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
+			}
+		}
+		prog->numknownstrings++;
+	}
+	prog->firstfreeknownstring = i + 1;
+	prog->knownstrings[i] = s;
+	return -1 - i;
+}
+
+int PRVM_AllocString(size_t bufferlength, char **pointer)
+{
+	int i;
+	if (!bufferlength)
+		return 0;
+	for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
+		if (!prog->knownstrings[i])
+			break;
+	if (i >= prog->numknownstrings)
+	{
+		if (i >= prog->maxknownstrings)
+		{
+			const char **oldstrings = prog->knownstrings;
+			const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
+			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->numknownstrings)
+			{
+				memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
+				memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
+			}
+		}
+		prog->numknownstrings++;
+	}
+	prog->firstfreeknownstring = i + 1;
+	prog->knownstrings[i] = (char *)PRVM_Alloc(bufferlength);
+	prog->knownstrings_freeable[i] = true;
+	if (pointer)
+		*pointer = (char *)(prog->knownstrings[i]);
+	return -1 - i;
+}
+
+void PRVM_FreeString(int num)
+{
+	if (num == 0)
+		PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string");
+	else if (num >= 0 && num < prog->stringssize)
+		PRVM_ERROR("PRVM_FreeString: attempt to free a constant string");
+	else if (num < 0 && num >= -prog->numknownstrings)
+	{
+		num = -1 - num;
+		if (!prog->knownstrings[num])
+			PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string");
+		if (!prog->knownstrings[num])
+			PRVM_ERROR("PRVM_FreeString: attempt to free a string owned by the engine");
+		PRVM_Free((char *)prog->knownstrings[num]);
+		prog->knownstrings[num] = NULL;
+		prog->knownstrings_freeable[num] = false;
+		prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
+	}
+	else
+		PRVM_ERROR("PRVM_FreeString: invalid string offset %i", num);
+}
+