X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=a819196f4a0a74933b9dbb50efa33aa781d6f18c;hp=1b2f87ae74f7b54ed123170e2cc2bfdc4da32d04;hb=624b2a6616c0e07574000dba59e0f46c8f12d8f9;hpb=52de46587c44c52da685cd24de040d70728ce815

diff --git a/prvm_cmds.c b/prvm_cmds.c
index 1b2f87ae..a819196f 100644
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -7,21 +7,31 @@
 #include "quakedef.h"
 
 #include "prvm_cmds.h"
+#include "libcurl.h"
 #include <time.h>
 
+extern cvar_t prvm_backtraceforwarnings;
+
 // LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
 void VM_Warning(const char *fmt, ...)
 {
 	va_list argptr;
 	char msg[MAX_INPUTLINE];
+	static double recursive = -1;
 
 	va_start(argptr,fmt);
 	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 	va_end(argptr);
 
 	Con_Print(msg);
+
 	// TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
-	//PRVM_PrintState();
+	if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
+	{
+		recursive = realtime;
+		PRVM_PrintState();
+		recursive = -1;
+	}
 }
 
 
@@ -35,7 +45,7 @@ void VM_Warning(const char *fmt, ...)
 
 void VM_CheckEmptyString (const char *s)
 {
-	if (s[0] <= ' ')
+	if (ISWHITESPACE(s[0]))
 		PRVM_ERROR ("%s: Bad string", PRVM_NAME);
 }
 
@@ -320,50 +330,14 @@ void VM_vectoyaw (void)
 =================
 VM_vectoangles
 
-vector vectoangles(vector)
+vector vectoangles(vector[, vector])
 =================
 */
 void VM_vectoangles (void)
 {
-	float	*value1;
-	float	forward;
-	float	yaw, pitch;
-
-	VM_SAFEPARMCOUNT(1,VM_vectoangles);
-
-	value1 = PRVM_G_VECTOR(OFS_PARM0);
-
-	if (value1[1] == 0 && value1[0] == 0)
-	{
-		yaw = 0;
-		if (value1[2] > 0)
-			pitch = 90;
-		else
-			pitch = 270;
-	}
-	else
-	{
-		// LordHavoc: optimized a bit
-		if (value1[0])
-		{
-			yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
-			if (yaw < 0)
-				yaw += 360;
-		}
-		else if (value1[1] > 0)
-			yaw = 90;
-		else
-			yaw = 270;
+	VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles);
 
-		forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
-		pitch = (atan2(value1[2], forward) * 180 / M_PI);
-		if (pitch < 0)
-			pitch += 360;
-	}
-
-	PRVM_G_FLOAT(OFS_RETURN+0) = pitch;
-	PRVM_G_FLOAT(OFS_RETURN+1) = yaw;
-	PRVM_G_FLOAT(OFS_RETURN+2) = 0;
+	AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true);
 }
 
 /*
@@ -455,6 +429,52 @@ void VM_cvar (void)
 	PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
 }
 
+/*
+=================
+VM_cvar
+
+float cvar_type (string)
+float CVAR_TYPEFLAG_EXISTS = 1;
+float CVAR_TYPEFLAG_SAVED = 2;
+float CVAR_TYPEFLAG_PRIVATE = 4;
+float CVAR_TYPEFLAG_ENGINE = 8;
+float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
+float CVAR_TYPEFLAG_READONLY = 32;
+=================
+*/
+void VM_cvar_type (void)
+{
+	char string[VM_STRINGTEMP_LENGTH];
+	cvar_t *cvar;
+	int ret;
+
+	VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
+	VM_VarString(0, string, sizeof(string));
+	VM_CheckEmptyString(string);
+	cvar = Cvar_FindVar(string);
+
+
+	if(!cvar)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = 0;
+		return; // CVAR_TYPE_NONE
+	}
+
+	ret = 1; // CVAR_EXISTS
+	if(cvar->flags & CVAR_SAVE)
+		ret |= 2; // CVAR_TYPE_SAVED
+	if(cvar->flags & CVAR_PRIVATE)
+		ret |= 4; // CVAR_TYPE_PRIVATE
+	if(!(cvar->flags & CVAR_ALLOCATED))
+		ret |= 8; // CVAR_TYPE_ENGINE
+	if(cvar->description != cvar_dummy_description)
+		ret |= 16; // CVAR_TYPE_HASDESCRIPTION
+	if(cvar->flags & CVAR_READONLY)
+		ret |= 32; // CVAR_TYPE_READONLY
+	
+	PRVM_G_FLOAT(OFS_RETURN) = ret;
+}
+
 /*
 =================
 VM_cvar_string
@@ -487,6 +507,22 @@ void VM_cvar_defstring (void)
 	VM_CheckEmptyString(string);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string));
 }
+
+/*
+========================
+VM_cvar_defstring
+
+const string	VM_cvar_description (string, ...)
+========================
+*/
+void VM_cvar_description (void)
+{
+	char string[VM_STRINGTEMP_LENGTH];
+	VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_description);
+	VM_VarString(0, string, sizeof(string));
+	VM_CheckEmptyString(string);
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDescription(string));
+}
 /*
 =================
 VM_cvar_set
@@ -545,9 +581,9 @@ void VM_ftos (void)
 	v = PRVM_G_FLOAT(OFS_PARM0);
 
 	if ((float)((int)v) == v)
-		sprintf(s, "%i", (int)v);
+		dpsnprintf(s, sizeof(s), "%i", (int)v);
 	else
-		sprintf(s, "%f", v);
+		dpsnprintf(s, sizeof(s), "%f", v);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -583,7 +619,7 @@ void VM_vtos (void)
 
 	VM_SAFEPARMCOUNT(1,VM_vtos);
 
-	sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
+	dpsnprintf (s, sizeof(s), "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -601,7 +637,7 @@ void VM_etos (void)
 
 	VM_SAFEPARMCOUNT(1, VM_etos);
 
-	sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
+	dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -652,6 +688,19 @@ void VM_ftoe(void)
 	PRVM_G_INT(OFS_RETURN) = ent;
 }
 
+/*
+========================
+VM_etof
+
+float etof(entity ent)
+========================
+*/
+void VM_etof(void)
+{
+	VM_SAFEPARMCOUNT(1, VM_etof);
+	PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0);
+}
+
 /*
 =========
 VM_strftime
@@ -662,23 +711,40 @@ string strftime(float uselocaltime, string[, string ...])
 void VM_strftime(void)
 {
 	time_t t;
+#if _MSC_VER >= 1400
+	struct tm tm;
+	int tmresult;
+#else
 	struct tm *tm;
+#endif
 	char fmt[VM_STRINGTEMP_LENGTH];
 	char result[VM_STRINGTEMP_LENGTH];
 	VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime);
 	VM_VarString(1, fmt, sizeof(fmt));
 	t = time(NULL);
+#if _MSC_VER >= 1400
+	if (PRVM_G_FLOAT(OFS_PARM0))
+		tmresult = localtime_s(&tm, &t);
+	else
+		tmresult = gmtime_s(&tm, &t);
+	if (!tmresult)
+#else
 	if (PRVM_G_FLOAT(OFS_PARM0))
 		tm = localtime(&t);
 	else
 		tm = gmtime(&t);
 	if (!tm)
+#endif
 	{
-		PRVM_G_FLOAT(OFS_RETURN) = 0;
+		PRVM_G_INT(OFS_RETURN) = 0;
 		return;
 	}
+#if _MSC_VER >= 1400
+	strftime(result, sizeof(result), fmt, &tm);
+#else
 	strftime(result, sizeof(result), fmt, tm);
-	PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result);
+#endif
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result);
 }
 
 /*
@@ -1392,7 +1458,7 @@ void VM_registercvar (void)
 		return;
 	}
 
-	Cvar_Get(name, value, flags);
+	Cvar_Get(name, value, flags, NULL);
 
 	PRVM_G_FLOAT(OFS_RETURN) = 1; // success
 }
@@ -1539,28 +1605,29 @@ void VM_fopen(void)
 		VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
 		return;
 	}
+	filename = PRVM_G_STRING(OFS_PARM0);
 	mode = (int)PRVM_G_FLOAT(OFS_PARM1);
 	switch(mode)
 	{
 	case 0: // FILE_READ
 		modestring = "rb";
+		prog->openfiles[filenum] = FS_OpenVirtualFile(va("data/%s", filename), false);
+		if (prog->openfiles[filenum] == NULL)
+			prog->openfiles[filenum] = FS_OpenVirtualFile(va("%s", filename), false);
 		break;
 	case 1: // FILE_APPEND
-		modestring = "ab";
+		modestring = "a";
+		prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
 		break;
 	case 2: // FILE_WRITE
-		modestring = "wb";
+		modestring = "w";
+		prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
 		break;
 	default:
 		PRVM_G_FLOAT(OFS_RETURN) = -3;
 		VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
 		return;
 	}
-	filename = PRVM_G_STRING(OFS_PARM0);
-
-	prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
-	if (prog->openfiles[filenum] == NULL && mode == 0)
-		prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false);
 
 	if (prog->openfiles[filenum] == NULL)
 	{
@@ -1573,6 +1640,7 @@ void VM_fopen(void)
 		PRVM_G_FLOAT(OFS_RETURN) = filenum;
 		if (developer.integer >= 100)
 			Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
+		prog->openfiles_origin[filenum] = PRVM_AllocationOrigin();
 	}
 }
 
@@ -1603,6 +1671,8 @@ void VM_fclose(void)
 	}
 	FS_Close(prog->openfiles[filenum]);
 	prog->openfiles[filenum] = NULL;
+	if(prog->openfiles_origin[filenum])
+		PRVM_Free((char *)prog->openfiles_origin[filenum]);
 	if (developer.integer >= 100)
 		Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
 }
@@ -1623,6 +1693,9 @@ void VM_fgets(void)
 
 	VM_SAFEPARMCOUNT(1,VM_fgets);
 
+	// set the return value regardless of any possible errors
+	PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+
 	filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
 	if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
 	{
@@ -1655,8 +1728,6 @@ void VM_fgets(void)
 		Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
 	if (c >= 0 || end)
 		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
-	else
-		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
 }
 
 /*
@@ -1724,6 +1795,155 @@ void VM_writetofile(void)
 	PRVM_ED_Write (file, ent);
 }
 
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_numentityfields
+
+float() numentityfields
+Return the number of entity fields - NOT offsets
+=========
+*/
+void VM_numentityfields(void)
+{
+	PRVM_G_FLOAT(OFS_RETURN) = prog->progs->numfielddefs;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldname
+
+string(float fieldnum) entityfieldname
+Return name of the specified field as a string, or empty if the field is invalid (warning)
+=========
+*/
+void VM_entityfieldname(void)
+{
+	ddef_t *d;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfieldname: %s: field index out of bounds\n", PRVM_NAME);
+        PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldtype
+
+float(float fieldnum) entityfieldtype
+=========
+*/
+void VM_entityfieldtype(void)
+{
+	ddef_t *d;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+		VM_Warning("VM_entityfieldtype: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_FLOAT(OFS_RETURN) = -1.0;
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	PRVM_G_FLOAT(OFS_RETURN) = (float)d->type;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_getentityfieldstring
+
+string(float fieldnum, entity ent) getentityfieldstring
+=========
+*/
+void VM_getentityfieldstring(void)
+{
+	// put the data into a string
+	ddef_t *d;
+	int type, j;
+	int *v;
+	prvm_edict_t * ent;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	
+	// get the entity
+	ent = PRVM_G_EDICT(OFS_PARM1);
+	if(ent->priv.required->free)
+	{
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+		return;
+	}
+	v = (int *)((char *)ent->fields.vp + d->ofs*4);
+	
+	// if it's 0 or blank, return an empty string
+	type = d->type & ~DEF_SAVEGLOBAL;
+	for (j=0 ; j<prvm_type_size[type] ; j++)
+		if (v[j])
+			break;
+	if (j == prvm_type_size[type])
+	{
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+		
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_putentityfieldstring
+
+float(float fieldnum, entity ent, string s) putentityfieldstring
+=========
+*/
+void VM_putentityfieldstring(void)
+{
+	ddef_t *d;
+	prvm_edict_t * ent;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+		return;
+	}
+
+	d = &prog->fielddefs[i];
+
+	// get the entity
+	ent = PRVM_G_EDICT(OFS_PARM1);
+	if(ent->priv.required->free)
+	{
+		VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+		PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+		return;
+	}
+
+	// parse the string into the value
+	PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f;
+}
+
 /*
 =========
 VM_strlen
@@ -1756,9 +1976,7 @@ void VM_strdecolorize(void)
 	// Prepare Strings
 	VM_SAFEPARMCOUNT(1,VM_strdecolorize);
 	szString = PRVM_G_STRING(OFS_PARM0);
-
 	COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
-
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
 }
 
@@ -2071,24 +2289,67 @@ float tokenize(string s)
 //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
 //this function originally written by KrimZon, made shorter by LordHavoc
 //20040203: rewritten by LordHavoc (no longer uses allocations)
-int num_tokens = 0;
-int tokens[256];
+static int num_tokens = 0;
+static int tokens[256];
+static int tokens_startpos[256];
+static int tokens_endpos[256];
+static char tokenize_string[VM_STRINGTEMP_LENGTH];
 void VM_tokenize (void)
 {
 	const char *p;
-	static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
 
 	VM_SAFEPARMCOUNT(1,VM_tokenize);
 
-	strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
-	p = string;
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
+
+	num_tokens = 0;
+	for(;;)
+	{
+		if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
+			break;
+
+		// skip whitespace here to find token start pos
+		while(*p && ISWHITESPACE(*p))
+			++p;
+
+		tokens_startpos[num_tokens] = p - tokenize_string;
+		if(!COM_ParseToken_VM_Tokenize(&p, false))
+			break;
+		tokens_endpos[num_tokens] = p - tokenize_string;
+		tokens[num_tokens] = PRVM_SetTempString(com_token);
+		++num_tokens;
+	}
+
+	PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
+}
+
+//float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many
+void VM_tokenize_console (void)
+{
+	const char *p;
+
+	VM_SAFEPARMCOUNT(1,VM_tokenize);
+
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
 
 	num_tokens = 0;
-	while(COM_ParseToken_VM_Tokenize(&p, false))
+	for(;;)
 	{
 		if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
 			break;
-		tokens[num_tokens++] = PRVM_SetTempString(com_token);
+
+		// skip whitespace here to find token start pos
+		while(*p && ISWHITESPACE(*p))
+			++p;
+
+		tokens_startpos[num_tokens] = p - tokenize_string;
+		if(!COM_ParseToken_Console(&p))
+			break;
+		tokens_endpos[num_tokens] = p - tokenize_string;
+		tokens[num_tokens] = PRVM_SetTempString(com_token);
+		++num_tokens;
 	}
 
 	PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
@@ -2117,14 +2378,13 @@ void VM_tokenizebyseparator (void)
 	const char *p;
 	const char *token;
 	char tokentext[MAX_INPUTLINE];
-	static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
 
 	VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
 
-	strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
-	p = string;
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
 
-	numseparators = 0;;
+	numseparators = 0;
 	for (j = 1;j < prog->argc;j++)
 	{
 		// skip any blank separator strings
@@ -2142,6 +2402,7 @@ void VM_tokenizebyseparator (void)
 	while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
 	{
 		token = tokentext + j;
+		tokens_startpos[num_tokens] = p - tokenize_string;
 		while (*p)
 		{
 			for (k = 0;k < numseparators;k++)
@@ -2158,6 +2419,7 @@ void VM_tokenizebyseparator (void)
 				tokentext[j++] = *p;
 			p++;
 		}
+		tokens_endpos[num_tokens] = p - tokenize_string;
 		if (j >= (int)sizeof(tokentext))
 			break;
 		tokentext[j++] = 0;
@@ -2179,12 +2441,51 @@ void VM_argv (void)
 
 	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
 
+	if(token_num < 0)
+		token_num += num_tokens;
+
 	if (token_num >= 0 && token_num < num_tokens)
 		PRVM_G_INT(OFS_RETURN) = tokens[token_num];
 	else
 		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
 }
 
+//float(float n) argv_start_index = #515; // returns the start index of a token
+void VM_argv_start_index (void)
+{
+	int token_num;
+
+	VM_SAFEPARMCOUNT(1,VM_argv);
+
+	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if(token_num < 0)
+		token_num += num_tokens;
+
+	if (token_num >= 0 && token_num < num_tokens)
+		PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num];
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
+//float(float n) argv_end_index = #516; // returns the end index of a token
+void VM_argv_end_index (void)
+{
+	int token_num;
+
+	VM_SAFEPARMCOUNT(1,VM_argv);
+
+	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if(token_num < 0)
+		token_num += num_tokens;
+
+	if (token_num >= 0 && token_num < num_tokens)
+		PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num];
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
 /*
 =========
 VM_isserver
@@ -2224,7 +2525,22 @@ void VM_clientstate(void)
 {
 	VM_SAFEPARMCOUNT(0,VM_clientstate);
 
-	PRVM_G_FLOAT(OFS_RETURN) = cls.state;
+
+	switch( cls.state ) {
+		case ca_uninitialized:
+		case ca_dedicated:
+			PRVM_G_FLOAT(OFS_RETURN) = 0;
+			break;
+		case ca_disconnected:
+			PRVM_G_FLOAT(OFS_RETURN) = 1;
+			break;
+		case ca_connected:
+			PRVM_G_FLOAT(OFS_RETURN) = 2;
+			break;
+		default:
+			// should never be reached!
+			break;
+	}
 }
 
 /*
@@ -2253,23 +2569,6 @@ void VM_getostype(void)
 #endif
 }
 
-/*
-=========
-VM_getmousepos
-
-vector	getmousepos()
-=========
-*/
-void VM_getmousepos(void)
-{
-
-	VM_SAFEPARMCOUNT(0,VM_getmousepos);
-
-	PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x * vid_conwidth.integer / vid.width;
-	PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y * vid_conheight.integer / vid.height;
-	PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
-}
-
 /*
 =========
 VM_gettime
@@ -2433,7 +2732,10 @@ void VM_search_begin(void)
 	if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
 	else
+	{
+		prog->opensearches_origin[handle] = PRVM_AllocationOrigin();
 		PRVM_G_FLOAT(OFS_RETURN) = handle;
+	}
 }
 
 /*
@@ -2463,6 +2765,8 @@ void VM_search_end(void)
 
 	FS_FreeSearch(prog->opensearches[handle]);
 	prog->opensearches[handle] = NULL;
+	if(prog->opensearches_origin[handle])
+		PRVM_Free((char *)prog->opensearches_origin[handle]);
 }
 
 /*
@@ -2581,7 +2885,7 @@ void VM_precache_pic(void)
 	VM_CheckEmptyString (s);
 
 	// AK Draw_CachePic is supposed to always return a valid pointer
-	if( Draw_CachePic(s, false)->tex == r_texture_notexture )
+	if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture )
 		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
 }
 
@@ -2608,7 +2912,7 @@ dp_font_t *getdrawfont()
 {
 	if(prog->globaloffsets.drawfont >= 0)
 	{
-		int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+		int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
 		if(f < 0 || f >= MAX_FONTS)
 			return FONT_DEFAULT;
 		return &dp_fonts[f];
@@ -2723,7 +3027,7 @@ void VM_drawcolorcodedstring(void)
 	string = PRVM_G_STRING(OFS_PARM1);
 	pos = PRVM_G_VECTOR(OFS_PARM0);
 	scale = PRVM_G_VECTOR(OFS_PARM2);
-	flag = (int)PRVM_G_FLOAT(OFS_PARM5);
+	flag = (int)PRVM_G_FLOAT(OFS_PARM4);
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
@@ -2762,7 +3066,7 @@ void VM_stringwidth(void)
 	string = PRVM_G_STRING(OFS_PARM0);
 	colors = (int)PRVM_G_FLOAT(OFS_PARM1);
 
-	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_String_Font(0, 0, string, 0, 1, 1, 0, 0, 0, 0, 0, NULL, !colors, getdrawfont()); // 1x1 characters, don't actually draw
+	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
 }
 /*
 =========
@@ -2805,7 +3109,7 @@ void VM_drawpic(void)
 	if(pos[2] || size[2])
 		Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
 
-	DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
+	DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 /*
@@ -2853,7 +3157,7 @@ void VM_drawsubpic(void)
 	if(pos[2] || size[2])
 		Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
 
-	DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic(picname, true),
+	DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname),
 		size[0], size[1],
 		srcPos[0],              srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
 		srcPos[0] + srcSize[0], srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
@@ -2948,7 +3252,7 @@ void VM_getimagesize(void)
 	p = PRVM_G_STRING(OFS_PARM0);
 	VM_CheckEmptyString (p);
 
-	pic = Draw_CachePic (p, false);
+	pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT);
 
 	PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
 	PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
@@ -2969,6 +3273,40 @@ void VM_keynumtostring (void)
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0)));
 }
 
+/*
+=========
+VM_findkeysforcommand
+
+string	findkeysforcommand(string command)
+
+the returned string is an altstring
+=========
+*/
+#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
+
+void M_FindKeysForCommand(const char *command, int *keys);
+void VM_findkeysforcommand(void)
+{
+	const char *cmd;
+	char ret[VM_STRINGTEMP_LENGTH];
+	int keys[NUMKEYS];
+	int i;
+
+	VM_SAFEPARMCOUNT(1, VM_findkeysforcommand);
+
+	cmd = PRVM_G_STRING(OFS_PARM0);
+
+	VM_CheckEmptyString(cmd);
+
+	M_FindKeysForCommand(cmd, keys);
+
+	ret[0] = 0;
+	for(i = 0; i < NUMKEYS; i++)
+		strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret));
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret);
+}
+
 /*
 =========
 VM_stringtokeynum
@@ -3100,7 +3438,6 @@ void VM_cin_restart( void )
 		CL_RestartVideo( video );
 }
 
-#ifdef SUPPORT_GECKO
 /*
 ========================
 VM_Gecko_Init
@@ -3156,7 +3493,7 @@ void VM_gecko_create( void ) {
 			return;
 	}
 
-	instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name );
+	instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() );
    if( !instance ) {
 		// TODO: error handling [12/3/2007 Black]
 		PRVM_G_FLOAT( OFS_RETURN ) = 0;
@@ -3256,7 +3593,7 @@ void VM_gecko_keyevent( void ) {
 		return;
 	}
 
-	PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+	PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true);
 }
 
 /*
@@ -3284,7 +3621,63 @@ void VM_gecko_movemouse( void ) {
 	}
 	CL_Gecko_Event_CursorMove( instance, x, y );
 }
-#endif
+
+
+/*
+========================
+VM_gecko_resize
+
+void gecko_resize( string name, float w, float h )
+========================
+*/
+void VM_gecko_resize( void ) {
+	const char *name;
+	float w, h;
+	clgecko_t *instance;
+
+	VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+	name = PRVM_G_STRING( OFS_PARM0 );
+	VM_CheckEmptyString( name );
+	w = PRVM_G_FLOAT( OFS_PARM1 );
+	h = PRVM_G_FLOAT( OFS_PARM2 );
+	
+	instance = CL_Gecko_FindBrowser( name );
+	if( !instance ) {
+		return;
+	}
+	CL_Gecko_Resize( instance, (int) w, (int) h );
+}
+
+
+/*
+========================
+VM_gecko_get_texture_extent
+
+vector gecko_get_texture_extent( string name )
+========================
+*/
+void VM_gecko_get_texture_extent( void ) {
+	const char *name;
+	clgecko_t *instance;
+
+	VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse );
+
+	name = PRVM_G_STRING( OFS_PARM0 );
+	VM_CheckEmptyString( name );
+	
+	PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+	instance = CL_Gecko_FindBrowser( name );
+	if( !instance ) {
+		PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
+		PRVM_G_VECTOR(OFS_RETURN)[1] = 0;
+		return;
+	}
+	CL_Gecko_GetTextureExtent( instance, 
+		PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 );
+}
+
+
 
 /*
 ==============
@@ -3575,67 +3968,41 @@ void VM_altstr_ins(void)
 // BufString functions
 ////////////////////////////////////////
 //[515]: string buffers support
-#define MAX_QCSTR_BUFFERS 128
-#define MAX_QCSTR_STRINGS 1024
-
-typedef struct
-{
-	int		num_strings;
-	char	*strings[MAX_QCSTR_STRINGS];
-}qcstrbuffer_t;
 
-// FIXME: move stringbuffers to prog_t to allow multiple progs!
-static qcstrbuffer_t	*qcstringbuffers[MAX_QCSTR_BUFFERS];
-static int				num_qcstringbuffers;
-static int				buf_sortpower;
+static size_t stringbuffers_sortlength;
 
-#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a])
-#define BUFSTR_ISFREE(a) (a<MAX_QCSTR_BUFFERS&&qcstringbuffers[a]&&qcstringbuffers[a]->num_strings<=0) ? 1 : 0
-
-static int BufStr_FindFreeBuffer (void)
+static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex)
 {
-	int	i;
-	if(num_qcstringbuffers == MAX_QCSTR_BUFFERS)
-		return -1;
-	for(i=0;i<MAX_QCSTR_BUFFERS;i++)
-		if(!qcstringbuffers[i])
-		{
-			qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
-			memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
-			return i;
-		}
-	return -1;
+	if (stringbuffer->max_strings <= strindex)
+	{
+		char **oldstrings = stringbuffer->strings;
+		stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
+		while (stringbuffer->max_strings <= strindex)
+			stringbuffer->max_strings *= 2;
+		stringbuffer->strings = (char **) Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
+		if (stringbuffer->num_strings > 0)
+			memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
+		if (oldstrings)
+			Mem_Free(oldstrings);
+	}
 }
 
-static void BufStr_ClearBuffer (int index)
+static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer)
 {
-	qcstrbuffer_t	*b = qcstringbuffers[index];
-	int				i;
+	// reduce num_strings if there are empty string slots at the end
+	while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL)
+		stringbuffer->num_strings--;
 
-	if(b)
+	// if empty, free the string pointer array
+	if (stringbuffer->num_strings == 0)
 	{
-		if(b->num_strings > 0)
-		{
-			for(i=0;i<b->num_strings;i++)
-				if(b->strings[i])
-					Z_Free(b->strings[i]);
-			num_qcstringbuffers--;
-		}
-		Z_Free(qcstringbuffers[index]);
-		qcstringbuffers[index] = NULL;
+		stringbuffer->max_strings = 0;
+		if (stringbuffer->strings)
+			Mem_Free(stringbuffer->strings);
+		stringbuffer->strings = NULL;
 	}
 }
 
-static int BufStr_FindFreeString (qcstrbuffer_t *b)
-{
-	int				i;
-	for(i=0;i<b->num_strings;i++)
-		if(!b->strings[i] || !b->strings[i][0])
-			return i;
-	if(i == MAX_QCSTR_STRINGS)	return -1;
-	else						return i;
-}
-
 static int BufStr_SortStringsUP (const void *in1, const void *in2)
 {
 	const char *a, *b;
@@ -3643,7 +4010,7 @@ static int BufStr_SortStringsUP (const void *in1, const void *in2)
 	b = *((const char **) in2);
 	if(!a[0])	return 1;
 	if(!b[0])	return -1;
-	return strncmp(a, b, buf_sortpower);
+	return strncmp(a, b, stringbuffers_sortlength);
 }
 
 static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
@@ -3653,7 +4020,7 @@ static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
 	b = *((const char **) in2);
 	if(!a[0])	return 1;
 	if(!b[0])	return -1;
-	return strncmp(b, a, buf_sortpower);
+	return strncmp(b, a, stringbuffers_sortlength);
 }
 
 /*
@@ -3665,13 +4032,12 @@ float buf_create(void) = #460;
 */
 void VM_buf_create (void)
 {
+	prvm_stringbuffer_t *stringbuffer;
 	int i;
 	VM_SAFEPARMCOUNT(0, VM_buf_create);
-	i = BufStr_FindFreeBuffer();
-	if(i >= 0)
-		num_qcstringbuffers++;
-	//else
-		//Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME);
+	stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
+	for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
+	stringbuffer->origin = PRVM_AllocationOrigin();
 	PRVM_G_FLOAT(OFS_RETURN) = i;
 }
 
@@ -3684,9 +4050,21 @@ void buf_del(float bufhandle) = #461;
 */
 void VM_buf_del (void)
 {
+	prvm_stringbuffer_t *stringbuffer;
 	VM_SAFEPARMCOUNT(1, VM_buf_del);
-	if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)))
-		BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if (stringbuffer)
+	{
+		int i;
+		for (i = 0;i < stringbuffer->num_strings;i++)
+			if (stringbuffer->strings[i])
+				Mem_Free(stringbuffer->strings[i]);
+		if (stringbuffer->strings)
+			Mem_Free(stringbuffer->strings);
+		if(stringbuffer->origin)
+			PRVM_Free((char *)stringbuffer->origin);
+		Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
+	}
 	else
 	{
 		VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
@@ -3703,18 +4081,18 @@ float buf_getsize(float bufhandle) = #462;
 */
 void VM_buf_getsize (void)
 {
-	qcstrbuffer_t	*b;
+	prvm_stringbuffer_t *stringbuffer;
 	VM_SAFEPARMCOUNT(1, VM_buf_getsize);
 
-	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
-	if(!b)
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
 	{
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
 		VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
 	else
-		PRVM_G_FLOAT(OFS_RETURN) = b->num_strings;
+		PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings;
 }
 
 /*
@@ -3726,12 +4104,12 @@ void buf_copy(float bufhandle_from, float bufhandle_to) = #463;
 */
 void VM_buf_copy (void)
 {
-	qcstrbuffer_t	*b1, *b2;
-	int				i;
+	prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer;
+	int i;
 	VM_SAFEPARMCOUNT(2, VM_buf_copy);
 
-	b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
-	if(!b1)
+	srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!srcstringbuffer)
 	{
 		VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
@@ -3742,31 +4120,32 @@ void VM_buf_copy (void)
 		VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
 		return;
 	}
-	b2 = BUFSTR_BUFFER(i);
-	if(!b2)
+	dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!dststringbuffer)
 	{
 		VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
 		return;
 	}
 
-	BufStr_ClearBuffer(i);
-	qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
-	memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
-	b2->num_strings = b1->num_strings;
+	for (i = 0;i < dststringbuffer->num_strings;i++)
+		if (dststringbuffer->strings[i])
+			Mem_Free(dststringbuffer->strings[i]);
+	if (dststringbuffer->strings)
+		Mem_Free(dststringbuffer->strings);
+	*dststringbuffer = *srcstringbuffer;
+	if (dststringbuffer->max_strings)
+		dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings);
 
-	for(i=0;i<b1->num_strings;i++)
-		if(b1->strings[i] && b1->strings[i][0])
+	for (i = 0;i < dststringbuffer->num_strings;i++)
+	{
+		if (srcstringbuffer->strings[i])
 		{
 			size_t stringlen;
-			stringlen = strlen(b1->strings[i]) + 1;
-			b2->strings[i] = (char *)Z_Malloc(stringlen);
-			if(!b2->strings[i])
-			{
-				VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
-				break;
-			}
-			memcpy(b2->strings[i], b1->strings[i], stringlen);
+			stringlen = strlen(srcstringbuffer->strings[i]) + 1;
+			dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen);
+			memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen);
 		}
+	}
 }
 
 /*
@@ -3779,45 +4158,30 @@ void buf_sort(float bufhandle, float cmplength, float backward) = #464;
 */
 void VM_buf_sort (void)
 {
-	qcstrbuffer_t	*b;
-	int				i;
+	prvm_stringbuffer_t *stringbuffer;
 	VM_SAFEPARMCOUNT(3, VM_buf_sort);
 
-	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
-	if(!b)
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
 	{
 		VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
-	if(b->num_strings <= 0)
+	if(stringbuffer->num_strings <= 0)
 	{
 		VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
-	// TODO: please someone rename this to buf_cmplength [12/3/2007 Black]
-	buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
-	if(buf_sortpower <= 0)
-		buf_sortpower = 99999999;
+	stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(stringbuffers_sortlength <= 0)
+		stringbuffers_sortlength = 0x7FFFFFFF;
 
 	if(!PRVM_G_FLOAT(OFS_PARM2))
-		qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP);
+		qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP);
 	else
-		qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
+		qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
 
-	for(i=b->num_strings-1;i>=0;i--)	//[515]: delete empty lines
-		if(b->strings)
-		{
-			if(b->strings[i][0])
-				break;
-			else
-			{
-				Z_Free(b->strings[i]);
-				--b->num_strings;
-				b->strings[i] = NULL;
-			}
-		}
-		else
-			--b->num_strings;
+	BufStr_Shrink(stringbuffer);
 }
 
 /*
@@ -3829,33 +4193,35 @@ string buf_implode(float bufhandle, string glue) = #465;
 */
 void VM_buf_implode (void)
 {
-	qcstrbuffer_t	*b;
+	prvm_stringbuffer_t *stringbuffer;
 	char			k[VM_STRINGTEMP_LENGTH];
 	const char		*sep;
 	int				i;
 	size_t			l;
 	VM_SAFEPARMCOUNT(2, VM_buf_implode);
 
-	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
 	PRVM_G_INT(OFS_RETURN) = OFS_NULL;
-	if(!b)
+	if(!stringbuffer)
 	{
 		VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
-	if(!b->num_strings)
+	if(!stringbuffer->num_strings)
 		return;
 	sep = PRVM_G_STRING(OFS_PARM1);
 	k[0] = 0;
-	for(l=i=0;i<b->num_strings;i++)
-		if(b->strings[i])
+	for(l = i = 0;i < stringbuffer->num_strings;i++)
+	{
+		if(stringbuffer->strings[i])
 		{
-			l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]);
+			l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]);
 			if (l >= sizeof(k) - 1)
 				break;
 			strlcat(k, sep, sizeof(k));
-			strlcat(k, b->strings[i], sizeof(k));
+			strlcat(k, stringbuffer->strings[i], sizeof(k));
 		}
+	}
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k);
 }
 
@@ -3868,27 +4234,25 @@ string bufstr_get(float bufhandle, float string_index) = #465;
 */
 void VM_bufstr_get (void)
 {
-	qcstrbuffer_t	*b;
+	prvm_stringbuffer_t *stringbuffer;
 	int				strindex;
 	VM_SAFEPARMCOUNT(2, VM_bufstr_get);
 
 	PRVM_G_INT(OFS_RETURN) = OFS_NULL;
-	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
-	if(!b)
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
 	{
 		VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
 	strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
-	if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+	if (strindex < 0)
 	{
 		VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
 		return;
 	}
-	if(b->num_strings <= strindex)
-		return;
-	if(b->strings[strindex])
-		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]);
+	if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex])
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(stringbuffer->strings[strindex]);
 }
 
 /*
@@ -3900,88 +4264,88 @@ void bufstr_set(float bufhandle, float string_index, string str) = #466;
 */
 void VM_bufstr_set (void)
 {
-	int				bufindex, strindex;
-	qcstrbuffer_t	*b;
+	int				strindex;
+	prvm_stringbuffer_t *stringbuffer;
 	const char		*news;
-	size_t			alloclen;
 
 	VM_SAFEPARMCOUNT(3, VM_bufstr_set);
 
-	bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
-	b = BUFSTR_BUFFER(bufindex);
-	if(!b)
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
 	{
-		VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+		VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
 	strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
-	if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+	if(strindex < 0 || strindex >= 1000000) // huge number of strings
 	{
 		VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
 		return;
 	}
+
+	BufStr_Expand(stringbuffer, strindex);
+	stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
+
+	if(stringbuffer->strings[strindex])
+		Mem_Free(stringbuffer->strings[strindex]);
+	stringbuffer->strings[strindex] = NULL;
+
 	news = PRVM_G_STRING(OFS_PARM2);
-	if(b->strings[strindex])
-		Z_Free(b->strings[strindex]);
-	alloclen = strlen(news) + 1;
-	b->strings[strindex] = (char *)Z_Malloc(alloclen);
-	memcpy(b->strings[strindex], news, alloclen);
+	if (news && news[0])
+	{
+		size_t alloclen = strlen(news) + 1;
+		stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+		memcpy(stringbuffer->strings[strindex], news, alloclen);
+	}
+
+	BufStr_Shrink(stringbuffer);
 }
 
 /*
 ========================
 VM_bufstr_add
-adds string to buffer in nearest free slot and returns it
+adds string to buffer in first free slot and returns its index
 "order == TRUE" means that string will be added after last "full" slot
 float bufstr_add(float bufhandle, string str, float order) = #467;
 ========================
 */
 void VM_bufstr_add (void)
 {
-	int				bufindex, order, strindex;
-	qcstrbuffer_t	*b;
+	int				order, strindex;
+	prvm_stringbuffer_t *stringbuffer;
 	const char		*string;
 	size_t			alloclen;
 
 	VM_SAFEPARMCOUNT(3, VM_bufstr_add);
 
-	bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
-	b = BUFSTR_BUFFER(bufindex);
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
 	PRVM_G_FLOAT(OFS_RETURN) = -1;
-	if(!b)
+	if(!stringbuffer)
 	{
-		VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+		VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
 	string = PRVM_G_STRING(OFS_PARM1);
+	if(!string || !string[0])
+	{
+		VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
 	order = (int)PRVM_G_FLOAT(OFS_PARM2);
 	if(order)
-		strindex = b->num_strings;
+		strindex = stringbuffer->num_strings;
 	else
-	{
-		strindex = BufStr_FindFreeString(b);
-		if(strindex < 0)
-		{
-			VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
-			return;
-		}
-	}
+		for (strindex = 0;strindex < stringbuffer->num_strings;strindex++)
+			if (stringbuffer->strings[strindex] == NULL)
+				break;
 
-	while(b->num_strings <= strindex)
-	{
-		if(b->num_strings == MAX_QCSTR_STRINGS)
-		{
-			VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
-			return;
-		}
-		b->strings[b->num_strings] = NULL;
-		b->num_strings++;
-	}
-	if(b->strings[strindex])
-		Z_Free(b->strings[strindex]);
+	BufStr_Expand(stringbuffer, strindex);
+
+	stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
 	alloclen = strlen(string) + 1;
-	b->strings[strindex] = (char *)Z_Malloc(alloclen);
-	memcpy(b->strings[strindex], string, alloclen);
+	stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+	memcpy(stringbuffer->strings[strindex], string, alloclen);
+
 	PRVM_G_FLOAT(OFS_RETURN) = strindex;
 }
 
@@ -3995,28 +4359,117 @@ void bufstr_free(float bufhandle, float string_index) = #468;
 void VM_bufstr_free (void)
 {
 	int				i;
-	qcstrbuffer_t	*b;
+	prvm_stringbuffer_t	*stringbuffer;
 	VM_SAFEPARMCOUNT(2, VM_bufstr_free);
 
-	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
-	if(!b)
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
 	{
 		VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
 	i = (int)PRVM_G_FLOAT(OFS_PARM1);
-	if(i < 0 || i > MAX_QCSTR_STRINGS)
+	if(i < 0)
 	{
 		VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
 		return;
 	}
-	if(b->strings[i])
-		Z_Free(b->strings[i]);
-	b->strings[i] = NULL;
-	if(i+1 == b->num_strings)
-		--b->num_strings;
+
+	if (i < stringbuffer->num_strings)
+	{
+		if(stringbuffer->strings[i])
+			Mem_Free(stringbuffer->strings[i]);
+		stringbuffer->strings[i] = NULL;
+	}
+
+	BufStr_Shrink(stringbuffer);
+}
+
+
+
+
+
+
+
+void VM_buf_cvarlist(void)
+{
+	cvar_t *cvar;
+	const char *partial, *antipartial;
+	size_t len, antilen;
+	size_t alloclen;
+	qboolean ispattern, antiispattern;
+	int n;
+	prvm_stringbuffer_t	*stringbuffer;
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist);
+
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
+	{
+		VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+
+	partial = PRVM_G_STRING(OFS_PARM1);
+	if(!partial)
+		len = 0;
+	else
+		len = strlen(partial);
+
+	if(prog->argc == 3)
+		antipartial = PRVM_G_STRING(OFS_PARM2);
+	else
+		antipartial = NULL;
+	if(!antipartial)
+		antilen = 0;
+	else
+		antilen = strlen(antipartial);
+	
+	for (n = 0;n < stringbuffer->num_strings;n++)
+		if (stringbuffer->strings[n])
+			Mem_Free(stringbuffer->strings[n]);
+	if (stringbuffer->strings)
+		Mem_Free(stringbuffer->strings);
+	stringbuffer->strings = NULL;
+
+	ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
+	antiispattern = antipartial && (strchr(antipartial, '*') || strchr(antipartial, '?'));
+
+	n = 0;
+	for(cvar = cvar_vars; cvar; cvar = cvar->next)
+	{
+		if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+			continue;
+
+		if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+			continue;
+
+		++n;
+	}
+
+	stringbuffer->max_strings = stringbuffer->num_strings = n;
+	if (stringbuffer->max_strings)
+		stringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(stringbuffer->strings[0]) * stringbuffer->max_strings);
+	
+	n = 0;
+	for(cvar = cvar_vars; cvar; cvar = cvar->next)
+	{
+		if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+			continue;
+
+		if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+			continue;
+
+		alloclen = strlen(cvar->name) + 1;
+		stringbuffer->strings[n] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+		memcpy(stringbuffer->strings[n], cvar->name, alloclen);
+
+		++n;
+	}
 }
 
+
+
+
 //=============
 
 /*
@@ -4141,50 +4594,18 @@ void VM_changepitch (void)
 	PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move);
 }
 
-// TODO: adapt all static function names to use a single naming convention... [12/3/2007 Black]
-static int Is_Text_Color (char c, char t)
-{
-	int a = 0;
-	char c2 = c - (c & 128);
-	char t2 = t - (t & 128);
-
-	if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG)		return 0;
-	if(t >= '0' && t <= '9')		a = 1;
-	if(t2 >= '0' && t2 <= '9')		a = 1;
-/*	if(t >= 'A' && t <= 'Z')		a = 2;
-	if(t2 >= 'A' && t2 <= 'Z')		a = 2;
-
-	if(a == 1 && scr_colortext.integer > 0)
-		return 1;
-	if(a == 2 && scr_multifonts.integer > 0)
-		return 2;
-*/
-	return a;
-}
 
 void VM_uncolorstring (void)
 {
-	const char	*in;
-	char		out[VM_STRINGTEMP_LENGTH];
-	int			k = 0, i = 0;
+	char szNewString[VM_STRINGTEMP_LENGTH];
+	const char *szString;
 
+	// Prepare Strings
 	VM_SAFEPARMCOUNT(1, VM_uncolorstring);
-	in = PRVM_G_STRING(OFS_PARM0);
-	VM_CheckEmptyString (in);
-
-	while (in[k])
-	{
-		if(in[k+1])
-		if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/)
-		{
-			k += 2;
-			continue;
-		}
-		out[i] = in[k];
-		++k;
-		++i;
-	}
-	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out);
+	szString = PRVM_G_STRING(OFS_PARM0);
+	COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
+	
 }
 
 // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
@@ -4196,7 +4617,7 @@ void VM_strstrofs (void)
 	VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs);
 	instr = PRVM_G_STRING(OFS_PARM0);
 	match = PRVM_G_STRING(OFS_PARM1);
-	firstofs = (prog->argc > 2)?PRVM_G_FLOAT(OFS_PARM2):0;
+	firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
 
 	if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
 	{
@@ -4325,9 +4746,9 @@ void VM_strconv (void)
 
 	VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv);
 
-	ccase = PRVM_G_FLOAT(OFS_PARM0);	//0 same, 1 lower, 2 upper
-	redalpha = PRVM_G_FLOAT(OFS_PARM1);	//0 same, 1 white, 2 red,  5 alternate, 6 alternate-alternate
-	rednum = PRVM_G_FLOAT(OFS_PARM2);	//0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
+	ccase = (int) PRVM_G_FLOAT(OFS_PARM0);	//0 same, 1 lower, 2 upper
+	redalpha = (int) PRVM_G_FLOAT(OFS_PARM1);	//0 same, 1 white, 2 red,  5 alternate, 6 alternate-alternate
+	rednum = (int) PRVM_G_FLOAT(OFS_PARM2);	//0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
 	VM_VarString(3, (char *) resbuf, sizeof(resbuf));
 	len = strlen((char *) resbuf);
 
@@ -4370,7 +4791,7 @@ void VM_strpad (void)
 	char destbuf[VM_STRINGTEMP_LENGTH];
 	int pad;
 	VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
-	pad = PRVM_G_FLOAT(OFS_PARM0);
+	pad = (int) PRVM_G_FLOAT(OFS_PARM0);
 	VM_VarString(1, src, sizeof(src));
 
 	// note: < 0 = left padding, > 0 = right padding,
@@ -4453,6 +4874,17 @@ void VM_strncasecmp (void)
 	}
 }
 
+// #494 float(float caseinsensitive, string s, ...) crc16
+void VM_crc16(void)
+{
+	float insensitive;
+	static char s[VM_STRINGTEMP_LENGTH];
+	VM_SAFEPARMCOUNTRANGE(2, 8, VM_hash);
+	insensitive = PRVM_G_FLOAT(OFS_PARM0);
+	VM_VarString(1, s, sizeof(s));
+	PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s)));
+}
+
 void VM_wasfreed (void)
 {
 	VM_SAFEPARMCOUNT(1, VM_wasfreed);
@@ -4497,9 +4929,7 @@ void VM_Cmd_Init(void)
 	// only init the stuff for the current prog
 	VM_Files_Init();
 	VM_Search_Init();
-#ifdef SUPPORT_GECKO
 	VM_Gecko_Init();
-#endif
 //	VM_BufStr_Init();
 }
 
@@ -4508,9 +4938,190 @@ void VM_Cmd_Reset(void)
 	CL_PurgeOwner( MENUOWNER );
 	VM_Search_Reset();
 	VM_Files_CloseAll();
-#ifdef SUPPORT_GECKO
 	VM_Gecko_Destroy();
-#endif
 //	VM_BufStr_ShutDown();
 }
 
+// #510 string(string input, ...) uri_escape (DP_QC_URI_ESCAPE)
+// does URI escaping on a string (replace evil stuff by %AB escapes)
+void VM_uri_escape (void)
+{
+	char src[VM_STRINGTEMP_LENGTH];
+	char dest[VM_STRINGTEMP_LENGTH];
+	char *p, *q;
+	static const char *hex = "0123456789ABCDEF";
+
+	VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_escape);
+	VM_VarString(0, src, sizeof(src));
+
+	for(p = src, q = dest; *p && q < dest + sizeof(dest) - 3; ++p)
+	{
+		if((*p >= 'A' && *p <= 'Z')
+			|| (*p >= 'a' && *p <= 'z')
+			|| (*p >= '0' && *p <= '9')
+			|| (*p == '-')  || (*p == '_') || (*p == '.')
+			|| (*p == '!')  || (*p == '~') || (*p == '*')
+			|| (*p == '\'') || (*p == '(') || (*p == ')'))
+			*q++ = *p;
+		else
+		{
+			*q++ = '%';
+			*q++ = hex[(*(unsigned char *)p >> 4) & 0xF];
+			*q++ = hex[ *(unsigned char *)p       & 0xF];
+		}
+	}
+	*q++ = 0;
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest);
+}
+
+// #510 string(string input, ...) uri_unescape (DP_QC_URI_ESCAPE)
+// does URI unescaping on a string (get back the evil stuff)
+void VM_uri_unescape (void)
+{
+	char src[VM_STRINGTEMP_LENGTH];
+	char dest[VM_STRINGTEMP_LENGTH];
+	char *p, *q;
+	int hi, lo;
+
+	VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_unescape);
+	VM_VarString(0, src, sizeof(src));
+
+	for(p = src, q = dest; *p; ) // no need to check size, because unescape can't expand
+	{
+		if(*p == '%')
+		{
+			if(p[1] >= '0' && p[1] <= '9')
+				hi = p[1] - '0';
+			else if(p[1] >= 'a' && p[1] <= 'f')
+				hi = p[1] - 'a' + 10;
+			else if(p[1] >= 'A' && p[1] <= 'F')
+				hi = p[1] - 'A' + 10;
+			else
+				goto nohex;
+			if(p[2] >= '0' && p[2] <= '9')
+				lo = p[2] - '0';
+			else if(p[2] >= 'a' && p[2] <= 'f')
+				lo = p[2] - 'a' + 10;
+			else if(p[2] >= 'A' && p[2] <= 'F')
+				lo = p[2] - 'A' + 10;
+			else
+				goto nohex;
+			if(hi != 0 || lo != 0) // don't unescape NUL bytes
+				*q++ = (char) (hi * 0x10 + lo);
+			p += 3;
+			continue;
+		}
+
+nohex:
+		// otherwise:
+		*q++ = *p++;
+	}
+	*q++ = 0;
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest);
+}
+
+// #502 string(string filename) whichpack (DP_QC_WHICHPACK)
+// returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant)
+void VM_whichpack (void)
+{
+	const char *fn, *pack;
+
+	VM_SAFEPARMCOUNT(1, VM_whichpack);
+	fn = PRVM_G_STRING(OFS_PARM0);
+	pack = FS_WhichPack(fn);
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(pack ? pack : "");
+}
+
+typedef struct
+{
+	int prognr;
+	double starttime;
+	float id;
+	char buffer[MAX_INPUTLINE];
+}
+uri_to_prog_t;
+
+static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata)
+{
+	uri_to_prog_t *handle = (uri_to_prog_t *) cbdata;
+
+	if(!PRVM_ProgLoaded(handle->prognr))
+	{
+		// curl reply came too late... so just drop it
+		Z_Free(handle);
+		return;
+	}
+		
+	PRVM_SetProg(handle->prognr);
+	PRVM_Begin;
+		if((prog->starttime == handle->starttime) && (prog->funcoffsets.URI_Get_Callback))
+		{
+			if(length_received >= sizeof(handle->buffer))
+				length_received = sizeof(handle->buffer) - 1;
+			handle->buffer[length_received] = 0;
+		
+			PRVM_G_FLOAT(OFS_PARM0) = handle->id;
+			PRVM_G_FLOAT(OFS_PARM1) = status;
+			PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(handle->buffer);
+			PRVM_ExecuteProgram(prog->funcoffsets.URI_Get_Callback, "QC function URI_Get_Callback is missing");
+		}
+	PRVM_End;
+	
+	Z_Free(handle);
+}
+
+// uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned
+// returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string
+void VM_uri_get (void)
+{
+	const char *url;
+	float id;
+	qboolean ret;
+	uri_to_prog_t *handle;
+
+	if(!prog->funcoffsets.URI_Get_Callback)
+		PRVM_ERROR("uri_get called by %s without URI_Get_Callback defined", PRVM_NAME);
+
+	VM_SAFEPARMCOUNT(2, VM_uri_get);
+
+	url = PRVM_G_STRING(OFS_PARM0);
+	id = PRVM_G_FLOAT(OFS_PARM1);
+	handle = (uri_to_prog_t *) Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later!
+
+	handle->prognr = PRVM_GetProgNr();
+	handle->starttime = prog->starttime;
+	handle->id = id;
+	ret = Curl_Begin_ToMemory(url, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+	if(ret)
+	{
+		PRVM_G_INT(OFS_RETURN) = 1;
+	}
+	else
+	{
+		Z_Free(handle);
+		PRVM_G_INT(OFS_RETURN) = 0;
+	}
+}
+
+void VM_netaddress_resolve (void)
+{
+	const char *ip;
+	char normalized[128];
+	int port;
+	lhnetaddress_t addr;
+
+	VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve);
+
+	ip = PRVM_G_STRING(OFS_PARM0);
+	port = 0;
+	if(prog->argc > 1)
+		port = (int) PRVM_G_FLOAT(OFS_PARM1);
+
+	if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1))
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(normalized);
+	else
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+}