X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=pr_exec.c;h=640140f2148cfc209f2972859df10ba0ba32cab1;hp=64abde5aab613476719e03fca55130f211c8b5d8;hb=65c5c9c594e16a38c8eae6107ea2b93237a9367f;hpb=cc63b89849022ef37ef113a7dc9489c2e846bd1b

diff --git a/pr_exec.c b/pr_exec.c
index 64abde5a..640140f2 100644
--- a/pr_exec.c
+++ b/pr_exec.c
@@ -21,26 +21,22 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "quakedef.h"
 
 
-/*
-
-*/
-
 typedef struct
 {
 	int				s;
 	dfunction_t		*f;
 } prstack_t;
 
-#define	MAX_STACK_DEPTH		32
+#define	MAX_STACK_DEPTH		256
 prstack_t	pr_stack[MAX_STACK_DEPTH];
-int			pr_depth;
+int			pr_depth = 0;
 
 #define	LOCALSTACK_SIZE		2048
 int			localstack[LOCALSTACK_SIZE];
 int			localstack_used;
 
 
-qboolean	pr_trace;
+int			pr_trace;
 dfunction_t	*pr_xfunction;
 int			pr_xstatement;
 
@@ -126,7 +122,7 @@ char *pr_opnames[] =
 "CALL8",
   
 "STATE",
-  
+
 "GOTO", 
   
 "AND",
@@ -150,7 +146,7 @@ PR_PrintStatement
 void PR_PrintStatement (dstatement_t *s)
 {
 	int		i;
-	
+
 	if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0]))
 	{
 		Con_Printf ("%s ",  pr_opnames[s->op]);
@@ -158,7 +154,7 @@ void PR_PrintStatement (dstatement_t *s)
 		for ( ; i<10 ; i++)
 			Con_Printf (" ");
 	}
-		
+
 	if (s->op == OP_IF || s->op == OP_IFNOT)
 		Con_Printf ("%sbranch %i",PR_GlobalString((unsigned short) s->a),s->b);
 	else if (s->op == OP_GOTO)
@@ -167,15 +163,15 @@ void PR_PrintStatement (dstatement_t *s)
 	}
 	else if ( (unsigned)(s->op - OP_STORE_F) < 6)
 	{
-		Con_Printf ("%s",PR_GlobalString((unsigned short) s->a));
+		Con_Printf ("%s", PR_GlobalString((unsigned short) s->a));
 		Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->b));
 	}
 	else
 	{
 		if (s->a)
-			Con_Printf ("%s",PR_GlobalString((unsigned short) s->a));
+			Con_Printf ("%s", PR_GlobalString((unsigned short) s->a));
 		if (s->b)
-			Con_Printf ("%s",PR_GlobalString((unsigned short) s->b));
+			Con_Printf ("%s", PR_GlobalString((unsigned short) s->b));
 		if (s->c)
 			Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->c));
 	}
@@ -191,24 +187,17 @@ void PR_StackTrace (void)
 {
 	dfunction_t	*f;
 	int			i;
-	
-	if (pr_depth == 0)
-	{
-		Con_Printf ("<NO STACK>\n");
-		return;
-	}
-	
+
+	pr_stack[pr_depth].s = pr_xstatement;
 	pr_stack[pr_depth].f = pr_xfunction;
-	for (i=pr_depth ; i>=0 ; i--)
+	for (i = pr_depth;i > 0;i--)
 	{
 		f = pr_stack[i].f;
-		
+
 		if (!f)
-		{
-			Con_Printf ("<NO FUNCTION>\n");
-		}
+			Con_Printf ("<NULL FUNCTION>\n");
 		else
-			Con_Printf ("%12s : %s\n", pr_strings + f->s_file, pr_strings + f->s_name);		
+			Con_Printf ("%12s : %s : statement %i\n", PR_GetString(f->s_file), PR_GetString(f->s_name), pr_stack[i].s - f->first_statement);
 	}
 }
 
@@ -225,8 +214,8 @@ void PR_Profile_f (void)
 	int			max;
 	int			num;
 	int			i;
-	
-	num = 0;	
+
+	num = 0;
 	do
 	{
 		max = 0;
@@ -243,7 +232,7 @@ void PR_Profile_f (void)
 		if (best)
 		{
 			if (num < 10)
-				Con_Printf ("%7i %s\n", best->profile, pr_strings+best->s_name);
+				Con_Printf ("%7i %s\n", best->profile, PR_GetString(best->s_name));
 			num++;
 			best->profile = 0;
 		}
@@ -251,29 +240,31 @@ void PR_Profile_f (void)
 }
 
 
-/*
-============
-PR_RunError
-
-Aborts the currently executing function
-============
-*/
-void PR_RunError (char *error, ...)
+void PR_Crash(void)
 {
-	va_list		argptr;
-	char		string[1024];
-
-	va_start (argptr,error);
-	vsprintf (string,error,argptr);
-	va_end (argptr);
+	int i;
+	if (pr_depth < 1)
+	{
+		// kill the stack just to be sure
+		pr_depth = 0;
+		localstack_used = 0;
+		return;
+	}
 
-	PR_PrintStatement (pr_statements + pr_xstatement);
+	Con_Printf("QuakeC crash report:\n");
+	if (pr_xfunction)
+	{
+		for (i = -4;i <= 0;i++)
+			if (pr_xstatement + i >= pr_xfunction->first_statement)
+				PR_PrintStatement (pr_statements + pr_xstatement + i);
+	}
+	else
+		Con_Printf("null function executing??\n");
 	PR_StackTrace ();
-	Con_Printf ("%s\n", string);
-	
-	pr_depth = 0;		// dump the stack so host_error can shutdown functions
 
-	Host_Error ("Program error");
+	// dump the stack so host_error can shutdown functions
+	pr_depth = 0;
+	localstack_used = 0;
 }
 
 /*
@@ -295,16 +286,19 @@ int PR_EnterFunction (dfunction_t *f)
 {
 	int		i, j, c, o;
 
+	if (!f)
+		Host_Error ("PR_EnterFunction: NULL function\n");
+
 	pr_stack[pr_depth].s = pr_xstatement;
-	pr_stack[pr_depth].f = pr_xfunction;	
+	pr_stack[pr_depth].f = pr_xfunction;
 	pr_depth++;
 	if (pr_depth >= MAX_STACK_DEPTH)
-		PR_RunError ("stack overflow");
+		Host_Error ("stack overflow");
 
 // save off any locals that the new function steps on
 	c = f->locals;
 	if (localstack_used + c > LOCALSTACK_SIZE)
-		PR_RunError ("PR_ExecuteProgram: locals stack overflow\n");
+		Host_Error ("PR_ExecuteProgram: locals stack overflow\n");
 
 	for (i=0 ; i < c ; i++)
 		localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
@@ -337,11 +331,13 @@ int PR_LeaveFunction (void)
 	if (pr_depth <= 0)
 		Host_Error ("prog stack underflow");
 
+	if (!pr_xfunction)
+		Host_Error ("PR_LeaveFunction: NULL function\n");
 // restore locals from the stack
 	c = pr_xfunction->locals;
 	localstack_used -= c;
 	if (localstack_used < 0)
-		PR_RunError ("PR_ExecuteProgram: locals stack underflow\n");
+		Host_Error ("PR_ExecuteProgram: locals stack underflow\n");
 
 	for (i=0 ; i < c ; i++)
 		((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];
@@ -352,963 +348,85 @@ int PR_LeaveFunction (void)
 	return pr_stack[pr_depth].s;
 }
 
+void PR_ReInitStrings (void);
+void PR_Execute_ProgsLoaded(void)
+{
+	// dump the stack
+	pr_depth = 0;
+	localstack_used = 0;
+	// reset the string table
+	PR_ReInitStrings();
+}
 
 /*
 ====================
 PR_ExecuteProgram
 ====================
 */
-/*
-void PR_ExecuteProgram (func_t fnum)
-{
-	eval_t	*a, *b, *c;
-	int			s;
-	dstatement_t	*st;
-	dfunction_t	*f, *newf;
-	int		runaway;
-	int		i;
-	edict_t	*ed;
-	int		exitdepth;
-	eval_t	*ptr;
-
-	if (!fnum || fnum >= progs->numfunctions)
-	{
-		if (pr_global_struct->self)
-			ED_Print (PROG_TO_EDICT(pr_global_struct->self));
-		Host_Error ("PR_ExecuteProgram: NULL function");
-	}
-	
-	f = &pr_functions[fnum];
-
-	runaway = 100000;
-	pr_trace = false;
-
-// make a stack frame
-	exitdepth = pr_depth;
-
-	s = PR_EnterFunction (f);
-	
-while (1)
-{
-	s++;	// next statement
-
-	st = &pr_statements[s];
-	// LordHavoc: fix for 32768 QC def limit (just added unsigned short typecast)
-	a = (eval_t *)&pr_globals[(unsigned short) st->a];
-	b = (eval_t *)&pr_globals[(unsigned short) st->b];
-	c = (eval_t *)&pr_globals[(unsigned short) st->c];
-	
-	if (!--runaway)
-		PR_RunError ("runaway loop error");
-		
-	pr_xfunction->profile++;
-	pr_xstatement = s;
-	
-	if (pr_trace)
-		PR_PrintStatement (st);
-		
-	switch (st->op)
-	{
-	case OP_ADD_F:
-		c->_float = a->_float + b->_float;
-		break;
-	case OP_ADD_V:
-		c->vector[0] = a->vector[0] + b->vector[0];
-		c->vector[1] = a->vector[1] + b->vector[1];
-		c->vector[2] = a->vector[2] + b->vector[2];
-		break;
-		
-	case OP_SUB_F:
-		c->_float = a->_float - b->_float;
-		break;
-	case OP_SUB_V:
-		c->vector[0] = a->vector[0] - b->vector[0];
-		c->vector[1] = a->vector[1] - b->vector[1];
-		c->vector[2] = a->vector[2] - b->vector[2];
-		break;
-
-	case OP_MUL_F:
-		c->_float = a->_float * b->_float;
-		break;
-	case OP_MUL_V:
-		c->_float = a->vector[0]*b->vector[0]
-				+ a->vector[1]*b->vector[1]
-				+ a->vector[2]*b->vector[2];
-		break;
-	case OP_MUL_FV:
-		c->vector[0] = a->_float * b->vector[0];
-		c->vector[1] = a->_float * b->vector[1];
-		c->vector[2] = a->_float * b->vector[2];
-		break;
-	case OP_MUL_VF:
-		c->vector[0] = b->_float * a->vector[0];
-		c->vector[1] = b->_float * a->vector[1];
-		c->vector[2] = b->_float * a->vector[2];
-		break;
-
-	case OP_DIV_F:
-		c->_float = a->_float / b->_float;
-		break;
-	
-	case OP_BITAND:
-		c->_float = (int)a->_float & (int)b->_float;
-		break;
-	
-	case OP_BITOR:
-		c->_float = (int)a->_float | (int)b->_float;
-		break;
-	
-		
-	case OP_GE:
-		c->_float = a->_float >= b->_float;
-		break;
-	case OP_LE:
-		c->_float = a->_float <= b->_float;
-		break;
-	case OP_GT:
-		c->_float = a->_float > b->_float;
-		break;
-	case OP_LT:
-		c->_float = a->_float < b->_float;
-		break;
-	case OP_AND:
-		c->_float = a->_float && b->_float;
-		break;
-	case OP_OR:
-		c->_float = a->_float || b->_float;
-		break;
-		
-	case OP_NOT_F:
-		c->_float = !a->_float;
-		break;
-	case OP_NOT_V:
-		c->_float = !a->vector[0] && !a->vector[1] && !a->vector[2];
-		break;
-	case OP_NOT_S:
-		c->_float = !a->string || !pr_strings[a->string];
-		break;
-	case OP_NOT_FNC:
-		c->_float = !a->function;
-		break;
-	case OP_NOT_ENT:
-		c->_float = (PROG_TO_EDICT(a->edict) == sv.edicts);
-		break;
-
-	case OP_EQ_F:
-		c->_float = a->_float == b->_float;
-		break;
-	case OP_EQ_V:
-		c->_float = (a->vector[0] == b->vector[0]) &&
-					(a->vector[1] == b->vector[1]) &&
-					(a->vector[2] == b->vector[2]);
-		break;
-	case OP_EQ_S:
-		c->_float = !strcmp(pr_strings+a->string,pr_strings+b->string);
-		break;
-	case OP_EQ_E:
-		c->_float = a->_int == b->_int;
-		break;
-	case OP_EQ_FNC:
-		c->_float = a->function == b->function;
-		break;
-
-
-	case OP_NE_F:
-		c->_float = a->_float != b->_float;
-		break;
-	case OP_NE_V:
-		c->_float = (a->vector[0] != b->vector[0]) ||
-					(a->vector[1] != b->vector[1]) ||
-					(a->vector[2] != b->vector[2]);
-		break;
-	case OP_NE_S:
-		c->_float = strcmp(pr_strings+a->string,pr_strings+b->string);
-		break;
-	case OP_NE_E:
-		c->_float = a->_int != b->_int;
-		break;
-	case OP_NE_FNC:
-		c->_float = a->function != b->function;
-		break;
-
-//==================
-	case OP_STORE_F:
-	case OP_STORE_ENT:
-	case OP_STORE_FLD:		// integers
-	case OP_STORE_S:
-	case OP_STORE_FNC:		// pointers
-		b->_int = a->_int;
-		break;
-	case OP_STORE_V:
-		b->vector[0] = a->vector[0];
-		b->vector[1] = a->vector[1];
-		b->vector[2] = a->vector[2];
-		break;
-		
-	case OP_STOREP_F:
-	case OP_STOREP_ENT:
-	case OP_STOREP_FLD:		// integers
-	case OP_STOREP_S:
-	case OP_STOREP_FNC:		// pointers
-		ptr = (eval_t *)((byte *)sv.edicts + b->_int);
-		ptr->_int = a->_int;
-		break;
-	case OP_STOREP_V:
-		ptr = (eval_t *)((byte *)sv.edicts + b->_int);
-		ptr->vector[0] = a->vector[0];
-		ptr->vector[1] = a->vector[1];
-		ptr->vector[2] = a->vector[2];
-		break;
-		
-	case OP_ADDRESS:
-		ed = PROG_TO_EDICT(a->edict);
-#ifdef PARANOID
-		NUM_FOR_EDICT(ed);		// make sure it's in range
-#endif
-		if (ed == (edict_t *)sv.edicts && sv.state == ss_active)
-			PR_RunError ("assignment to world entity");
-		c->_int = (byte *)((int *)&ed->v + b->_int) - (byte *)sv.edicts;
-		break;
-		
-	case OP_LOAD_F:
-	case OP_LOAD_FLD:
-	case OP_LOAD_ENT:
-	case OP_LOAD_S:
-	case OP_LOAD_FNC:
-		ed = PROG_TO_EDICT(a->edict);
-#ifdef PARANOID
-		NUM_FOR_EDICT(ed);		// make sure it's in range
-#endif
-		a = (eval_t *)((int *)&ed->v + b->_int);
-		c->_int = a->_int;
-		break;
-
-	case OP_LOAD_V:
-		ed = PROG_TO_EDICT(a->edict);
-#ifdef PARANOID
-		NUM_FOR_EDICT(ed);		// make sure it's in range
-#endif
-		a = (eval_t *)((int *)&ed->v + b->_int);
-		c->vector[0] = a->vector[0];
-		c->vector[1] = a->vector[1];
-		c->vector[2] = a->vector[2];
-		break;
-		
-//==================
-
-	case OP_IFNOT:
-		if (!a->_int)
-			s += st->b - 1;	// offset the s++
-		break;
-		
-	case OP_IF:
-		if (a->_int)
-			s += st->b - 1;	// offset the s++
-		break;
-		
-	case OP_GOTO:
-		s += st->a - 1;	// offset the s++
-		break;
-		
-	case OP_CALL0:
-	case OP_CALL1:
-	case OP_CALL2:
-	case OP_CALL3:
-	case OP_CALL4:
-	case OP_CALL5:
-	case OP_CALL6:
-	case OP_CALL7:
-	case OP_CALL8:
-		pr_argc = st->op - OP_CALL0;
-		if (!a->function)
-			PR_RunError ("NULL function");
-
-		newf = &pr_functions[a->function];
-
-		if (newf->first_statement < 0)
-		{	// negative statements are built in functions
-			i = -newf->first_statement;
-			if (i >= pr_numbuiltins)
-				PR_RunError ("Bad builtin call number");
-			pr_builtins[i] ();
-			break;
-		}
-
-		s = PR_EnterFunction (newf);
-		break;
-
-	case OP_DONE:
-	case OP_RETURN:
-		pr_globals[OFS_RETURN] = pr_globals[st->a];
-		pr_globals[OFS_RETURN+1] = pr_globals[st->a+1];
-		pr_globals[OFS_RETURN+2] = pr_globals[st->a+2];
-	
-		s = PR_LeaveFunction ();
-		if (pr_depth == exitdepth)
-			return;		// all done
-		break;
-		
-	case OP_STATE:
-		ed = PROG_TO_EDICT(pr_global_struct->self);
-#ifdef FPS_20
-		ed->v.nextthink = pr_global_struct->time + 0.05;
-#else
-		ed->v.nextthink = pr_global_struct->time + 0.1;
-#endif
-		//if (a->_float != ed->v.frame) // LordHavoc: this was silly
-		//{
-			ed->v.frame = a->_float;
-		//}
-		ed->v.think = b->function;
-		break;
-		
-	default:
-		PR_RunError ("Bad opcode %i", st->op);
-	}
-}
-
-}
-*/
-
 // LordHavoc: optimized
 #define OPA ((eval_t *)&pr_globals[(unsigned short) st->a])
 #define OPB ((eval_t *)&pr_globals[(unsigned short) st->b])
 #define OPC ((eval_t *)&pr_globals[(unsigned short) st->c])
 extern cvar_t pr_boundscheck;
-void PR_ExecuteProgram (func_t fnum)
+extern cvar_t pr_traceqc;
+void PR_ExecuteProgram (func_t fnum, const char *errormessage)
 {
 	dstatement_t	*st;
 	dfunction_t	*f, *newf;
 	edict_t	*ed;
-	int		exitdepth;
 	eval_t	*ptr;
-	int		profile, startprofile;
+	int		profile, startprofile, cachedpr_trace, exitdepth;
 
 	if (!fnum || fnum >= progs->numfunctions)
 	{
 		if (pr_global_struct->self)
 			ED_Print (PROG_TO_EDICT(pr_global_struct->self));
-		Host_Error ("PR_ExecuteProgram: NULL function");
+		Host_Error ("PR_ExecuteProgram: %s", errormessage);
 	}
-	
+
 	f = &pr_functions[fnum];
 
-	pr_trace = false;
+	pr_trace = pr_traceqc.integer;
 
-// make a stack frame
+	// we know we're done when pr_depth drops to this
 	exitdepth = pr_depth;
 
+// make a stack frame
 	st = &pr_statements[PR_EnterFunction (f)];
 	startprofile = profile = 0;
 
-	if (pr_boundscheck.value)
+chooseexecprogram:
+	cachedpr_trace = pr_trace;
+	if (pr_boundscheck.integer)
 	{
-		while (1)
+#define PRBOUNDSCHECK 1
+		if (pr_trace)
 		{
-			st++;
-			if (++profile > 100000)
-			{
-				pr_xstatement = st - pr_statements;
-				PR_RunError ("runaway loop error");
-			}
-			
-			if (pr_trace)
-				PR_PrintStatement (st);
-
-			switch (st->op)
-			{
-			case OP_ADD_F:
-				OPC->_float = OPA->_float + OPB->_float;
-				break;
-			case OP_ADD_V:
-				OPC->vector[0] = OPA->vector[0] + OPB->vector[0];
-				OPC->vector[1] = OPA->vector[1] + OPB->vector[1];
-				OPC->vector[2] = OPA->vector[2] + OPB->vector[2];
-				break;
-			case OP_SUB_F:
-				OPC->_float = OPA->_float - OPB->_float;
-				break;
-			case OP_SUB_V:
-				OPC->vector[0] = OPA->vector[0] - OPB->vector[0];
-				OPC->vector[1] = OPA->vector[1] - OPB->vector[1];
-				OPC->vector[2] = OPA->vector[2] - OPB->vector[2];
-				break;
-			case OP_MUL_F:
-				OPC->_float = OPA->_float * OPB->_float;
-				break;
-			case OP_MUL_V:
-				OPC->_float = OPA->vector[0]*OPB->vector[0] + OPA->vector[1]*OPB->vector[1] + OPA->vector[2]*OPB->vector[2];
-				break;
-			case OP_MUL_FV:
-				OPC->vector[0] = OPA->_float * OPB->vector[0];
-				OPC->vector[1] = OPA->_float * OPB->vector[1];
-				OPC->vector[2] = OPA->_float * OPB->vector[2];
-				break;
-			case OP_MUL_VF:
-				OPC->vector[0] = OPB->_float * OPA->vector[0];
-				OPC->vector[1] = OPB->_float * OPA->vector[1];
-				OPC->vector[2] = OPB->_float * OPA->vector[2];
-				break;
-			case OP_DIV_F:
-				OPC->_float = OPA->_float / OPB->_float;
-				break;
-			case OP_BITAND:
-				OPC->_float = (int)OPA->_float & (int)OPB->_float;
-				break;
-			case OP_BITOR:
-				OPC->_float = (int)OPA->_float | (int)OPB->_float;
-				break;
-			case OP_GE:
-				OPC->_float = OPA->_float >= OPB->_float;
-				break;
-			case OP_LE:
-				OPC->_float = OPA->_float <= OPB->_float;
-				break;
-			case OP_GT:
-				OPC->_float = OPA->_float > OPB->_float;
-				break;
-			case OP_LT:
-				OPC->_float = OPA->_float < OPB->_float;
-				break;
-			case OP_AND:
-				OPC->_float = OPA->_float && OPB->_float;
-				break;
-			case OP_OR:
-				OPC->_float = OPA->_float || OPB->_float;
-				break;
-			case OP_NOT_F:
-				OPC->_float = !OPA->_float;
-				break;
-			case OP_NOT_V:
-				OPC->_float = !OPA->vector[0] && !OPA->vector[1] && !OPA->vector[2];
-				break;
-			case OP_NOT_S:
-				OPC->_float = !OPA->string || !pr_strings[OPA->string];
-				break;
-			case OP_NOT_FNC:
-				OPC->_float = !OPA->function;
-				break;
-			case OP_NOT_ENT:
-				OPC->_float = (PROG_TO_EDICT(OPA->edict) == sv.edicts);
-				break;
-			case OP_EQ_F:
-				OPC->_float = OPA->_float == OPB->_float;
-				break;
-			case OP_EQ_V:
-				OPC->_float = (OPA->vector[0] == OPB->vector[0]) && (OPA->vector[1] == OPB->vector[1]) && (OPA->vector[2] == OPB->vector[2]);
-				break;
-			case OP_EQ_S:
-				OPC->_float = !strcmp(pr_strings+OPA->string,pr_strings+OPB->string);
-				break;
-			case OP_EQ_E:
-				OPC->_float = OPA->_int == OPB->_int;
-				break;
-			case OP_EQ_FNC:
-				OPC->_float = OPA->function == OPB->function;
-				break;
-			case OP_NE_F:
-				OPC->_float = OPA->_float != OPB->_float;
-				break;
-			case OP_NE_V:
-				OPC->_float = (OPA->vector[0] != OPB->vector[0]) || (OPA->vector[1] != OPB->vector[1]) || (OPA->vector[2] != OPB->vector[2]);
-				break;
-			case OP_NE_S:
-				OPC->_float = strcmp(pr_strings+OPA->string,pr_strings+OPB->string);
-				break;
-			case OP_NE_E:
-				OPC->_float = OPA->_int != OPB->_int;
-				break;
-			case OP_NE_FNC:
-				OPC->_float = OPA->function != OPB->function;
-				break;
-
-		//==================
-			case OP_STORE_F:
-			case OP_STORE_ENT:
-			case OP_STORE_FLD:		// integers
-			case OP_STORE_S:
-			case OP_STORE_FNC:		// pointers
-				OPB->_int = OPA->_int;
-				break;
-			case OP_STORE_V:
-				OPB->vector[0] = OPA->vector[0];
-				OPB->vector[1] = OPA->vector[1];
-				OPB->vector[2] = OPA->vector[2];
-				break;
-				
-			case OP_STOREP_F:
-			case OP_STOREP_ENT:
-			case OP_STOREP_FLD:		// integers
-			case OP_STOREP_S:
-			case OP_STOREP_FNC:		// pointers
-				if (OPB->_int < 0 || OPB->_int + 4 > pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an out of bounds edict\n");
-					return;
-				}
-				if (OPB->_int % pr_edict_size < ((byte *)&sv.edicts->v - (byte *)sv.edicts))
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an engine edict field\n");
-					return;
-				}
-				ptr = (eval_t *)((byte *)sv.edicts + OPB->_int);
-				ptr->_int = OPA->_int;
-				break;
-			case OP_STOREP_V:
-				if (OPB->_int < 0 || OPB->_int + 12 > pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an out of bounds edict\n");
-					return;
-				}
-				ptr = (eval_t *)((byte *)sv.edicts + OPB->_int);
-				ptr->vector[0] = OPA->vector[0];
-				ptr->vector[1] = OPA->vector[1];
-				ptr->vector[2] = OPA->vector[2];
-				break;
-				
-			case OP_ADDRESS:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to address an out of bounds edict\n");
-					return;
-				}
-				if (OPA->edict == 0 && sv.state == ss_active)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError ("assignment to world entity");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to address an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->_int = (byte *)((int *)&ed->v + OPB->_int) - (byte *)sv.edicts;
-				break;
-				
-			case OP_LOAD_F:
-			case OP_LOAD_FLD:
-			case OP_LOAD_ENT:
-			case OP_LOAD_S:
-			case OP_LOAD_FNC:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an out of bounds edict number\n");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->_int = ((eval_t *)((int *)&ed->v + OPB->_int))->_int;
-				break;
-
-			case OP_LOAD_V:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an out of bounds edict number\n");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int + 2 >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->vector[0] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[0];
-				OPC->vector[1] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[1];
-				OPC->vector[2] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[2];
-				break;
-				
-		//==================
-
-			case OP_IFNOT:
-				if (!OPA->_int)
-					st += st->b - 1;	// offset the s++
-				break;
-				
-			case OP_IF:
-				if (OPA->_int)
-					st += st->b - 1;	// offset the s++
-				break;
-				
-			case OP_GOTO:
-				st += st->a - 1;	// offset the s++
-				break;
-				
-			case OP_CALL0:
-			case OP_CALL1:
-			case OP_CALL2:
-			case OP_CALL3:
-			case OP_CALL4:
-			case OP_CALL5:
-			case OP_CALL6:
-			case OP_CALL7:
-			case OP_CALL8:
-				pr_xfunction->profile += profile - startprofile;
-				startprofile = profile;
-				pr_xstatement = st - pr_statements;
-				pr_argc = st->op - OP_CALL0;
-				if (!OPA->function)
-					PR_RunError ("NULL function");
-
-				newf = &pr_functions[OPA->function];
-
-				if (newf->first_statement < 0)
-				{	// negative statements are built in functions
-					int i = -newf->first_statement;
-					if (i >= pr_numbuiltins)
-						PR_RunError ("Bad builtin call number");
-					pr_builtins[i] ();
-					break;
-				}
-
-				st = &pr_statements[PR_EnterFunction (newf)];
-				break;
-
-			case OP_DONE:
-			case OP_RETURN:
-				pr_globals[OFS_RETURN] = pr_globals[(unsigned short) st->a];
-				pr_globals[OFS_RETURN+1] = pr_globals[(unsigned short) st->a+1];
-				pr_globals[OFS_RETURN+2] = pr_globals[(unsigned short) st->a+2];
-			
-				st = &pr_statements[PR_LeaveFunction ()];
-				if (pr_depth == exitdepth)
-					return;		// all done
-				break;
-				
-			case OP_STATE:
-				ed = PROG_TO_EDICT(pr_global_struct->self);
-		#ifdef FPS_20
-				ed->v.nextthink = pr_global_struct->time + 0.05;
-		#else
-				ed->v.nextthink = pr_global_struct->time + 0.1;
-		#endif
-				ed->v.frame = OPA->_float;
-				ed->v.think = OPB->function;
-				break;
-				
-			default:
-				pr_xstatement = st - pr_statements;
-				PR_RunError ("Bad opcode %i", st->op);
-			}
+#define PRTRACE 1
+#include "pr_execprogram.h"
+		}
+		else
+		{
+#undef PRTRACE
+#include "pr_execprogram.h"
 		}
 	}
 	else
 	{
-		while (1)
+#undef PRBOUNDSCHECK
+		if (pr_trace)
 		{
-			st++;
-			if (++profile > 100000)
-			{
-				pr_xstatement = st - pr_statements;
-				PR_RunError ("runaway loop error");
-			}
-			
-			if (pr_trace)
-				PR_PrintStatement (st);
-
-			switch (st->op)
-			{
-			case OP_ADD_F:
-				OPC->_float = OPA->_float + OPB->_float;
-				break;
-			case OP_ADD_V:
-				OPC->vector[0] = OPA->vector[0] + OPB->vector[0];
-				OPC->vector[1] = OPA->vector[1] + OPB->vector[1];
-				OPC->vector[2] = OPA->vector[2] + OPB->vector[2];
-				break;
-			case OP_SUB_F:
-				OPC->_float = OPA->_float - OPB->_float;
-				break;
-			case OP_SUB_V:
-				OPC->vector[0] = OPA->vector[0] - OPB->vector[0];
-				OPC->vector[1] = OPA->vector[1] - OPB->vector[1];
-				OPC->vector[2] = OPA->vector[2] - OPB->vector[2];
-				break;
-			case OP_MUL_F:
-				OPC->_float = OPA->_float * OPB->_float;
-				break;
-			case OP_MUL_V:
-				OPC->_float = OPA->vector[0]*OPB->vector[0] + OPA->vector[1]*OPB->vector[1] + OPA->vector[2]*OPB->vector[2];
-				break;
-			case OP_MUL_FV:
-				OPC->vector[0] = OPA->_float * OPB->vector[0];
-				OPC->vector[1] = OPA->_float * OPB->vector[1];
-				OPC->vector[2] = OPA->_float * OPB->vector[2];
-				break;
-			case OP_MUL_VF:
-				OPC->vector[0] = OPB->_float * OPA->vector[0];
-				OPC->vector[1] = OPB->_float * OPA->vector[1];
-				OPC->vector[2] = OPB->_float * OPA->vector[2];
-				break;
-			case OP_DIV_F:
-				OPC->_float = OPA->_float / OPB->_float;
-				break;
-			case OP_BITAND:
-				OPC->_float = (int)OPA->_float & (int)OPB->_float;
-				break;
-			case OP_BITOR:
-				OPC->_float = (int)OPA->_float | (int)OPB->_float;
-				break;
-			case OP_GE:
-				OPC->_float = OPA->_float >= OPB->_float;
-				break;
-			case OP_LE:
-				OPC->_float = OPA->_float <= OPB->_float;
-				break;
-			case OP_GT:
-				OPC->_float = OPA->_float > OPB->_float;
-				break;
-			case OP_LT:
-				OPC->_float = OPA->_float < OPB->_float;
-				break;
-			case OP_AND:
-				OPC->_float = OPA->_float && OPB->_float;
-				break;
-			case OP_OR:
-				OPC->_float = OPA->_float || OPB->_float;
-				break;
-			case OP_NOT_F:
-				OPC->_float = !OPA->_float;
-				break;
-			case OP_NOT_V:
-				OPC->_float = !OPA->vector[0] && !OPA->vector[1] && !OPA->vector[2];
-				break;
-			case OP_NOT_S:
-				OPC->_float = !OPA->string || !pr_strings[OPA->string];
-				break;
-			case OP_NOT_FNC:
-				OPC->_float = !OPA->function;
-				break;
-			case OP_NOT_ENT:
-				OPC->_float = (PROG_TO_EDICT(OPA->edict) == sv.edicts);
-				break;
-			case OP_EQ_F:
-				OPC->_float = OPA->_float == OPB->_float;
-				break;
-			case OP_EQ_V:
-				OPC->_float = (OPA->vector[0] == OPB->vector[0]) && (OPA->vector[1] == OPB->vector[1]) && (OPA->vector[2] == OPB->vector[2]);
-				break;
-			case OP_EQ_S:
-				OPC->_float = !strcmp(pr_strings+OPA->string,pr_strings+OPB->string);
-				break;
-			case OP_EQ_E:
-				OPC->_float = OPA->_int == OPB->_int;
-				break;
-			case OP_EQ_FNC:
-				OPC->_float = OPA->function == OPB->function;
-				break;
-			case OP_NE_F:
-				OPC->_float = OPA->_float != OPB->_float;
-				break;
-			case OP_NE_V:
-				OPC->_float = (OPA->vector[0] != OPB->vector[0]) || (OPA->vector[1] != OPB->vector[1]) || (OPA->vector[2] != OPB->vector[2]);
-				break;
-			case OP_NE_S:
-				OPC->_float = strcmp(pr_strings+OPA->string,pr_strings+OPB->string);
-				break;
-			case OP_NE_E:
-				OPC->_float = OPA->_int != OPB->_int;
-				break;
-			case OP_NE_FNC:
-				OPC->_float = OPA->function != OPB->function;
-				break;
-
-		//==================
-			case OP_STORE_F:
-			case OP_STORE_ENT:
-			case OP_STORE_FLD:		// integers
-			case OP_STORE_S:
-			case OP_STORE_FNC:		// pointers
-				OPB->_int = OPA->_int;
-				break;
-			case OP_STORE_V:
-				OPB->vector[0] = OPA->vector[0];
-				OPB->vector[1] = OPA->vector[1];
-				OPB->vector[2] = OPA->vector[2];
-				break;
-				
-			case OP_STOREP_F:
-			case OP_STOREP_ENT:
-			case OP_STOREP_FLD:		// integers
-			case OP_STOREP_S:
-			case OP_STOREP_FNC:		// pointers
-				if (OPB->_int < 0 || OPB->_int + 4 > pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an out of bounds edict\n");
-					return;
-				}
-				if (OPB->_int % pr_edict_size < ((byte *)&sv.edicts->v - (byte *)sv.edicts))
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an engine edict field\n");
-					return;
-				}
-				ptr = (eval_t *)((byte *)sv.edicts + OPB->_int);
-				ptr->_int = OPA->_int;
-				break;
-			case OP_STOREP_V:
-				if (OPB->_int < 0 || OPB->_int + 12 > pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to write to an out of bounds edict\n");
-					return;
-				}
-				ptr = (eval_t *)((byte *)sv.edicts + OPB->_int);
-				ptr->vector[0] = OPA->vector[0];
-				ptr->vector[1] = OPA->vector[1];
-				ptr->vector[2] = OPA->vector[2];
-				break;
-				
-			case OP_ADDRESS:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to address an out of bounds edict\n");
-					return;
-				}
-				if (OPA->edict == 0 && sv.state == ss_active)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError ("assignment to world entity");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to address an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->_int = (byte *)((int *)&ed->v + OPB->_int) - (byte *)sv.edicts;
-				break;
-				
-			case OP_LOAD_F:
-			case OP_LOAD_FLD:
-			case OP_LOAD_ENT:
-			case OP_LOAD_S:
-			case OP_LOAD_FNC:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an out of bounds edict number\n");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->_int = ((eval_t *)((int *)&ed->v + OPB->_int))->_int;
-				break;
-
-			case OP_LOAD_V:
-				if (OPA->edict < 0 || OPA->edict >= pr_edictareasize)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an out of bounds edict number\n");
-					return;
-				}
-				if (OPB->_int < 0 || OPB->_int + 2 >= progs->entityfields)
-				{
-					pr_xstatement = st - pr_statements;
-					PR_RunError("Progs attempted to read an invalid field in an edict\n");
-					return;
-				}
-				ed = PROG_TO_EDICT(OPA->edict);
-				OPC->vector[0] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[0];
-				OPC->vector[1] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[1];
-				OPC->vector[2] = ((eval_t *)((int *)&ed->v + OPB->_int))->vector[2];
-				break;
-				
-		//==================
-
-			case OP_IFNOT:
-				if (!OPA->_int)
-					st += st->b - 1;	// offset the s++
-				break;
-				
-			case OP_IF:
-				if (OPA->_int)
-					st += st->b - 1;	// offset the s++
-				break;
-				
-			case OP_GOTO:
-				st += st->a - 1;	// offset the s++
-				break;
-				
-			case OP_CALL0:
-			case OP_CALL1:
-			case OP_CALL2:
-			case OP_CALL3:
-			case OP_CALL4:
-			case OP_CALL5:
-			case OP_CALL6:
-			case OP_CALL7:
-			case OP_CALL8:
-				pr_xfunction->profile += profile - startprofile;
-				startprofile = profile;
-				pr_xstatement = st - pr_statements;
-				pr_argc = st->op - OP_CALL0;
-				if (!OPA->function)
-					PR_RunError ("NULL function");
-
-				newf = &pr_functions[OPA->function];
-
-				if (newf->first_statement < 0)
-				{	// negative statements are built in functions
-					int i = -newf->first_statement;
-					if (i >= pr_numbuiltins)
-						PR_RunError ("Bad builtin call number");
-					pr_builtins[i] ();
-					break;
-				}
-
-				st = &pr_statements[PR_EnterFunction (newf)];
-				break;
-
-			case OP_DONE:
-			case OP_RETURN:
-				pr_globals[OFS_RETURN] = pr_globals[(unsigned short) st->a];
-				pr_globals[OFS_RETURN+1] = pr_globals[(unsigned short) st->a+1];
-				pr_globals[OFS_RETURN+2] = pr_globals[(unsigned short) st->a+2];
-			
-				st = &pr_statements[PR_LeaveFunction ()];
-				if (pr_depth == exitdepth)
-					return;		// all done
-				break;
-				
-			case OP_STATE:
-				ed = PROG_TO_EDICT(pr_global_struct->self);
-		#ifdef FPS_20
-				ed->v.nextthink = pr_global_struct->time + 0.05;
-		#else
-				ed->v.nextthink = pr_global_struct->time + 0.1;
-		#endif
-				ed->v.frame = OPA->_float;
-				ed->v.think = OPB->function;
-				break;
-				
-			default:
-				pr_xstatement = st - pr_statements;
-				PR_RunError ("Bad opcode %i", st->op);
-			}
+#define PRTRACE 1
+#include "pr_execprogram.h"
+		}
+		else
+		{
+#undef PRTRACE
+#include "pr_execprogram.h"
 		}
 	}
 }
+
+void PR_ReInitStrings (void)
+{
+}