X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=pr_exec.c;h=e70f158159ddc69e9cfca1e51d6a07fce6669c19;hp=64abde5aab613476719e03fca55130f211c8b5d8;hb=be8d986d89e9ac7408134d9570ec398e535536e8;hpb=cc63b89849022ef37ef113a7dc9489c2e846bd1b

diff --git a/pr_exec.c b/pr_exec.c
index 64abde5a..e70f1581 100644
--- a/pr_exec.c
+++ b/pr_exec.c
@@ -358,324 +358,12 @@ int PR_LeaveFunction (void)
 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)
+void PR_ExecuteProgram (func_t fnum, char *errormessage)
 {
 	dstatement_t	*st;
 	dfunction_t	*f, *newf;
@@ -688,7 +376,7 @@ void PR_ExecuteProgram (func_t fnum)
 	{
 		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];
@@ -706,7 +394,7 @@ void PR_ExecuteProgram (func_t fnum)
 		while (1)
 		{
 			st++;
-			if (++profile > 100000)
+			if (++profile > 1000000) // LordHavoc: increased runaway loop limit 10x
 			{
 				pr_xstatement = st - pr_statements;
 				PR_RunError ("runaway loop error");
@@ -991,11 +679,7 @@ void PR_ExecuteProgram (func_t fnum)
 				
 			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;
@@ -1011,7 +695,7 @@ void PR_ExecuteProgram (func_t fnum)
 		while (1)
 		{
 			st++;
-			if (++profile > 100000)
+			if (++profile > 1000000) // LordHavoc: increased runaway loop limit 10x
 			{
 				pr_xstatement = st - pr_statements;
 				PR_RunError ("runaway loop error");
@@ -1296,15 +980,275 @@ void PR_ExecuteProgram (func_t fnum)
 				
 			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;
 				
+		//==================
+
+// LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized
+/*
+			case OP_ADD_I:
+				OPC->_int = OPA->_int + OPB->_int;
+				break;
+			case OP_ADD_IF:
+				OPC->_int = OPA->_int + (int) OPB->_float;
+				break;
+			case OP_ADD_FI:
+				OPC->_float = OPA->_float + (float) OPB->_int;
+				break;
+			case OP_SUB_I:
+				OPC->_int = OPA->_int - OPB->_int;
+				break;
+			case OP_SUB_IF:
+				OPC->_int = OPA->_int - (int) OPB->_float;
+				break;
+			case OP_SUB_FI:
+				OPC->_float = OPA->_float - (float) OPB->_int;
+				break;
+			case OP_MUL_I:
+				OPC->_int = OPA->_int * OPB->_int;
+				break;
+			case OP_MUL_IF:
+				OPC->_int = OPA->_int * (int) OPB->_float;
+				break;
+			case OP_MUL_FI:
+				OPC->_float = OPA->_float * (float) OPB->_int;
+				break;
+			case OP_MUL_VI:
+				OPC->vector[0] = (float) OPB->_int * OPA->vector[0];
+				OPC->vector[1] = (float) OPB->_int * OPA->vector[1];
+				OPC->vector[2] = (float) OPB->_int * OPA->vector[2];
+				break;
+			case OP_DIV_VF:
+				{
+					float temp = 1.0f / OPB->_float;
+					OPC->vector[0] = temp * OPA->vector[0];
+					OPC->vector[1] = temp * OPA->vector[1];
+					OPC->vector[2] = temp * OPA->vector[2];
+				}
+				break;
+			case OP_DIV_I:
+				OPC->_int = OPA->_int / OPB->_int;
+				break;
+			case OP_DIV_IF:
+				OPC->_int = OPA->_int / (int) OPB->_float;
+				break;
+			case OP_DIV_FI:
+				OPC->_float = OPA->_float / (float) OPB->_int;
+				break;
+			case OP_CONV_IF:
+				OPC->_float = OPA->_int;
+				break;
+			case OP_CONV_FI:
+				OPC->_int = OPA->_float;
+				break;
+			case OP_BITAND_I:
+				OPC->_int = OPA->_int & OPB->_int;
+				break;
+			case OP_BITOR_I:
+				OPC->_int = OPA->_int | OPB->_int;
+				break;
+			case OP_BITAND_IF:
+				OPC->_int = OPA->_int & (int)OPB->_float;
+				break;
+			case OP_BITOR_IF:
+				OPC->_int = OPA->_int | (int)OPB->_float;
+				break;
+			case OP_BITAND_FI:
+				OPC->_float = (int)OPA->_float & OPB->_int;
+				break;
+			case OP_BITOR_FI:
+				OPC->_float = (int)OPA->_float | OPB->_int;
+				break;
+			case OP_GE_I:
+				OPC->_float = OPA->_int >= OPB->_int;
+				break;
+			case OP_LE_I:
+				OPC->_float = OPA->_int <= OPB->_int;
+				break;
+			case OP_GT_I:
+				OPC->_float = OPA->_int > OPB->_int;
+				break;
+			case OP_LT_I:
+				OPC->_float = OPA->_int < OPB->_int;
+				break;
+			case OP_AND_I:
+				OPC->_float = OPA->_int && OPB->_int;
+				break;
+			case OP_OR_I:
+				OPC->_float = OPA->_int || OPB->_int;
+				break;
+			case OP_GE_IF:
+				OPC->_float = (float)OPA->_int >= OPB->_float;
+				break;
+			case OP_LE_IF:
+				OPC->_float = (float)OPA->_int <= OPB->_float;
+				break;
+			case OP_GT_IF:
+				OPC->_float = (float)OPA->_int > OPB->_float;
+				break;
+			case OP_LT_IF:
+				OPC->_float = (float)OPA->_int < OPB->_float;
+				break;
+			case OP_AND_IF:
+				OPC->_float = (float)OPA->_int && OPB->_float;
+				break;
+			case OP_OR_IF:
+				OPC->_float = (float)OPA->_int || OPB->_float;
+				break;
+			case OP_GE_FI:
+				OPC->_float = OPA->_float >= (float)OPB->_int;
+				break;
+			case OP_LE_FI:
+				OPC->_float = OPA->_float <= (float)OPB->_int;
+				break;
+			case OP_GT_FI:
+				OPC->_float = OPA->_float > (float)OPB->_int;
+				break;
+			case OP_LT_FI:
+				OPC->_float = OPA->_float < (float)OPB->_int;
+				break;
+			case OP_AND_FI:
+				OPC->_float = OPA->_float && (float)OPB->_int;
+				break;
+			case OP_OR_FI:
+				OPC->_float = OPA->_float || (float)OPB->_int;
+				break;
+			case OP_NOT_I:
+				OPC->_float = !OPA->_int;
+				break;
+			case OP_EQ_I:
+				OPC->_float = OPA->_int == OPB->_int;
+				break;
+			case OP_EQ_IF:
+				OPC->_float = (float)OPA->_int == OPB->_float;
+				break;
+			case OP_EQ_FI:
+				OPC->_float = OPA->_float == (float)OPB->_int;
+				break;
+			case OP_NE_I:
+				OPC->_float = OPA->_int != OPB->_int;
+				break;
+			case OP_NE_IF:
+				OPC->_float = (float)OPA->_int != OPB->_float;
+				break;
+			case OP_NE_FI:
+				OPC->_float = OPA->_float != (float)OPB->_int;
+				break;
+			case OP_STORE_I:
+				OPB->_int = OPA->_int;
+				break;
+			case OP_STOREP_I:
+				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_LOAD_I:
+				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_GSTOREP_I:
+			case OP_GSTOREP_F:
+			case OP_GSTOREP_ENT:
+			case OP_GSTOREP_FLD:		// integers
+			case OP_GSTOREP_S:
+			case OP_GSTOREP_FNC:		// pointers
+				if (OPB->_int < 0 || OPB->_int >= pr_globaldefs)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs attempted to write to an invalid indexed global\n");
+					return;
+				}
+				pr_globals[OPB->_int] = OPA->_float;
+				break;
+			case OP_GSTOREP_V:
+				if (OPB->_int < 0 || OPB->_int + 2 >= pr_globaldefs)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs attempted to write to an invalid indexed global\n");
+					return;
+				}
+				pr_globals[OPB->_int  ] = OPA->vector[0];
+				pr_globals[OPB->_int+1] = OPA->vector[1];
+				pr_globals[OPB->_int+2] = OPA->vector[2];
+				break;
+				
+			case OP_GADDRESS:
+				i = OPA->_int + (int) OPB->_float;
+				if (i < 0 || i >= pr_globaldefs)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs attempted to address an out of bounds global\n");
+					return;
+				}
+				OPC->_float = pr_globals[i];
+				break;
+				
+			case OP_GLOAD_I:
+			case OP_GLOAD_F:
+			case OP_GLOAD_FLD:
+			case OP_GLOAD_ENT:
+			case OP_GLOAD_S:
+			case OP_GLOAD_FNC:
+				if (OPA->_int < 0 || OPA->_int >= pr_globaldefs)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs attempted to read an invalid indexed global\n");
+					return;
+				}
+				OPC->_float = pr_globals[OPA->_int];
+				break;
+
+			case OP_GLOAD_V:
+				if (OPA->_int < 0 || OPA->_int + 2 >= pr_globaldefs)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs attempted to read an invalid indexed global\n");
+					return;
+				}
+				OPC->vector[0] = pr_globals[OPA->_int  ];
+				OPC->vector[1] = pr_globals[OPA->_int+1];
+				OPC->vector[2] = pr_globals[OPA->_int+2];
+				break;
+
+			case OP_BOUNDCHECK:
+				if (OPA->_int < 0 || OPA->_int >= st->b)
+				{
+					pr_xstatement = st - pr_statements;
+					PR_RunError("Progs boundcheck failed at line number %d, value is < 0 or >= %d\n", st->b, st->c);
+					return;
+				}
+				break;
+
+*/
+		//==================
+
 			default:
 				pr_xstatement = st - pr_statements;
 				PR_RunError ("Bad opcode %i", st->op);