PageRenderTime 45ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/quakeforge/branches/release_0_5_2/libs/gamecode/engine/pr_exec.c

#
C | 907 lines | 746 code | 75 blank | 86 comment | 102 complexity | 28d2f2ce95c889b9b608c4b8cabfb718 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, AGPL-3.0, AGPL-1.0, Unlicense 
    

  1. /*
    2. 

  2. 	pr_exec.c
    3. 

    4. 

  4. 	(description)
    5. 

    6. 

  6. 	Copyright (C) 1996-1997  Id Software, Inc.
    7. 

    8. 

  8. 	This program is free software; you can redistribute it and/or
    9. 

  9. 	modify it under the terms of the GNU General Public License
    10. 

  10. 	as published by the Free Software Foundation; either version 2
    11. 

  11. 	of the License, or (at your option) any later version.
    12. 

    13. 

  13. 	This program is distributed in the hope that it will be useful,
    14. 

  14. 	but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15. 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    16. 

    17. 

  17. 	See the GNU General Public License for more details.
    18. 

    19. 

  19. 	You should have received a copy of the GNU General Public License
    20. 

  20. 	along with this program; if not, write to:
    21. 

    22. 

  22. 		Free Software Foundation, Inc.
    23. 

  23. 		59 Temple Place - Suite 330
    24. 

  24. 		Boston, MA  02111-1307, USA
    25. 

    26. 

  26. */
    27. 

  27. static const char rcsid[] = 
    28. 

  28. 	"$Id: pr_exec.c 8535 2002-09-14 07:51:53Z taniwha $";
    29. 

  29. 

  30. #ifdef HAVE_CONFIG_H
    31. 

  31. # include "config.h"
    32. 

  32. #endif
    33. 

  33. #ifdef HAVE_STRING_H
    34. 

  34. # include <string.h>
    35. 

  35. #endif
    36. 

  36. #ifdef HAVE_STRINGS_H
    37. 

  37. # include <strings.h>
    38. 

  38. #endif
    39. 

  39. 

  40. #include <stdarg.h>
    41. 

  41. 

  42. #include "QF/cvar.h"
    43. 

  43. #include "QF/dstring.h"
    44. 

  44. #include "QF/mathlib.h"
    45. 

  45. #include "QF/progs.h"
    46. 

  46. #include "QF/sys.h"
    47. 

  47. #include "QF/zone.h"
    48. 

  48. 

  49. #include "compat.h"
    50. 

  50. 

  51. 

  52. void
    53. 

  53. PR_PrintStatement (progs_t * pr, dstatement_t *s)
    54. 

  54. {
    55. 

  55. 	int			addr = s - pr->pr_statements;
    56. 

  56. 	int			ofs;
    57. 

  57. 	opcode_t	*op;
    58. 

  58. 

  59. 	if (pr_debug->int_val && pr->debug) {
    60. 

  60. 		const char *source_line = PR_Get_Source_Line (pr, addr);
    61. 

  61. 

  62. 		if (source_line)
    63. 

  63. 			Sys_Printf ("%s\n", source_line);
    64. 

  64. 	}
    65. 

  65. 

  66. 	op = PR_Opcode (s->op);
    67. 

  67. 	if (!op) {
    68. 

  68. 		Sys_Printf ("Unknown instruction %d\n", s->op);
    69. 

  69. 		return;
    70. 

  70. 	}
    71. 

  71. 

  72. 	Sys_Printf ("%04x ", addr);
    73. 

  73. 	if (pr_debug->int_val > 1)
    74. 

  74. 		Sys_Printf ("%02x %04x(%s) %04x(%s) %04x(%s)\t",
    75. 

  75. 					s->op,
    76. 

  76. 					s->a, pr_type_name[op->type_a],
    77. 

  77. 					s->b, pr_type_name[op->type_b],
    78. 

  78. 					s->c, pr_type_name[op->type_c]);
    79. 

  79. 

  80. 	Sys_Printf ("%s ", op->opname);
    81. 

  81. 

  82. 	switch (s->op) {
    83. 

  83. 		case OP_IF:
    84. 

  84. 		case OP_IFNOT:
    85. 

  85. 		case OP_IFBE:
    86. 

  86. 		case OP_IFB:
    87. 

  87. 		case OP_IFAE:
    88. 

  88. 		case OP_IFA:
    89. 

  89. 			ofs = (short) s->b;
    90. 

  90. 

  91. 			Sys_Printf ("%s branch %i (%i)",
    92. 

  92. 					PR_GlobalString (pr, s->a, ev_integer)->str, ofs, addr + ofs);
    93. 

  93. 			break;
    94. 

  94. 

  95. 		case OP_GOTO:
    96. 

  96. 			ofs = (short) s->a;
    97. 

  97. 			Sys_Printf ("branch %i (%i)", ofs, addr + ofs);
    98. 

  98. 			break;
    99. 

  99. 

  100. 		case OP_RETURN:
    101. 

  101. 		case OP_DONE:
    102. 

  102. 			Sys_Printf ("%s", PR_GlobalString (pr, s->a, ev_void)->str);
    103. 

  103. 			break;
    104. 

  104. 

  105. 		default:
    106. 

  106. 			if (op->type_a != ev_void)
    107. 

  107. 				Sys_Printf ("%s", PR_GlobalString (pr, s->a, op->type_a)->str);
    108. 

  108. 

  109. 			if (op->type_b != ev_void) {
    110. 

  110. 				if (op->type_c != ev_void)
    111. 

  111. 					Sys_Printf (", %s", PR_GlobalString (pr, s->b, op->type_b)->str);
    112. 

  112. 				else
    113. 

  113. 					Sys_Printf (", %s",
    114. 

  114. 						PR_GlobalStringNoContents (pr, s->b, op->type_b)->str);
    115. 

  115. 			}
    116. 

  116. 

  117. 			if (op->type_c != ev_void) {
    118. 

  118. 				if (op->type_b == ev_pointer && op->type_c == ev_integer)
    119. 

  119. 					Sys_Printf (", %s", PR_GlobalString (pr, s->c, op->type_c)->str);
    120. 

  120. 				else
    121. 

  121. 					Sys_Printf (", %s",
    122. 

  122. 						PR_GlobalStringNoContents (pr, s->c, op->type_c)->str);
    123. 

  123. 			}
    124. 

  124. 	}
    125. 

  125. 	Sys_Printf ("\n");
    126. 

  126. }
    127. 

  127. 

  128. void
    129. 

  129. PR_StackTrace (progs_t * pr)
    130. 

  130. {
    131. 

  131. 	int				i;
    132. 

  132. 	dfunction_t	   *f;
    133. 

  133. 

  134. 	if (pr->pr_depth == 0) {
    135. 

  135. 		Sys_Printf ("<NO STACK>\n");
    136. 

  136. 		return;
    137. 

  137. 	}
    138. 

  138. 

  139. 	pr->pr_stack[pr->pr_depth].f = pr->pr_xfunction;
    140. 

  140. 	for (i = pr->pr_depth; i >= 0; i--) {
    141. 

  141. 		f = pr->pr_stack[i].f;
    142. 

  142. 

  143. 		if (!f) {
    144. 

  144. 			Sys_Printf ("<NO FUNCTION>\n");
    145. 

  145. 		} else
    146. 

  146. 			Sys_Printf ("%12s : %s\n", PR_GetString (pr, f->s_file),
    147. 

  147. 						PR_GetString (pr, f->s_name));
    148. 

  148. 	}
    149. 

  149. }
    150. 

  150. 

  151. void
    152. 

  152. PR_Profile (progs_t * pr)
    153. 

  153. {
    154. 

  154. 	int				max, num, i;
    155. 

  155. 	dfunction_t	   *best, *f;
    156. 

  156. 

  157. 	num = 0;
    158. 

  158. 	do {
    159. 

  159. 		max = 0;
    160. 

  160. 		best = NULL;
    161. 

  161. 		for (i = 0; i < pr->progs->numfunctions; i++) {
    162. 

  162. 			f = &pr->pr_functions[i];
    163. 

  163. 			if (f->profile > max) {
    164. 

  164. 				max = f->profile;
    165. 

  165. 				best = f;
    166. 

  166. 			}
    167. 

  167. 		}
    168. 

  168. 		if (best) {
    169. 

  169. 			if (num < 10)
    170. 

  170. 				Sys_Printf ("%7i %s\n", best->profile,
    171. 

  171. 							PR_GetString (pr, best->s_name));
    172. 

  172. 			num++;
    173. 

  173. 			best->profile = 0;
    174. 

  174. 		}
    175. 

  175. 	} while (best);
    176. 

  176. }
    177. 

  177. 

  178. /*
    179. 

  179. 	PR_RunError
    180. 

    181. 

  181. 	Aborts the currently executing function
    182. 

  182. */
    183. 

  183. void
    184. 

  184. PR_RunError (progs_t * pr, const char *error, ...)
    185. 

  185. {
    186. 

  186. 	char		string[1024];
    187. 

  187. 	va_list		argptr;
    188. 

  188. 

  189. 	va_start (argptr, error);
    190. 

  190. 	vsnprintf (string, sizeof (string), error, argptr);
    191. 

  191. 	va_end (argptr);
    192. 

  192. 

  193. 	PR_DumpState (pr);
    194. 

  194. 

  195. 	Sys_Printf ("%s\n", string);
    196. 

  196. 

  197. 	// dump the stack so PR_Error can shutdown functions
    198. 

  198. 	pr->pr_depth = 0;					
    199. 

  199. 

  200. 	PR_Error (pr, "Program error");
    201. 

  201. }
    202. 

  202. 

  203. /*
    204. 

  204. 	PR_EnterFunction
    205. 

    206. 

  206. 	Returns the new program statement counter
    207. 

  207. */
    208. 

  208. int
    209. 

  209. PR_EnterFunction (progs_t * pr, dfunction_t *f)
    210. 

  210. {
    211. 

  211. 	int			i, j, c, o;
    212. 

  212. 	int			k;
    213. 

  213. 

  214. 	//Sys_Printf("%s:\n", PR_GetString(pr,f->s_name));
    215. 

  215. 	pr->pr_stack[pr->pr_depth].s = pr->pr_xstatement;
    216. 

  216. 	pr->pr_stack[pr->pr_depth].f = pr->pr_xfunction;
    217. 

  217. 	pr->pr_depth++;
    218. 

  218. 	if (pr->pr_depth >= MAX_STACK_DEPTH)
    219. 

  219. 		PR_RunError (pr, "stack overflow");
    220. 

  220. 

  221. 	// save off any locals that the new function steps on
    222. 

  222. 	c = f->locals;
    223. 

  223. 	if (pr->localstack_used + c > LOCALSTACK_SIZE)
    224. 

  224. 		PR_RunError (pr, "PR_EnterFunction: locals stack overflow");
    225. 

  225. 

  226. 	memcpy (&pr->localstack[pr->localstack_used],
    227. 

  227. 			&pr->pr_globals[f->parm_start],
    228. 

  228. 			sizeof (pr_type_t) * c);
    229. 

  229. 	pr->localstack_used += c;
    230. 

  230. 

  231. 	if (pr_deadbeef_locals->int_val)
    232. 

  232. 		for (k = f->parm_start; k < f->parm_start + c; k++)
    233. 

  233. 			pr->pr_globals[k].integer_var = 0xdeadbeef;
    234. 

  234. 

  235. 	// copy parameters
    236. 

  236. 	o = f->parm_start;
    237. 

  237. 	if (f->numparms >= 0) {
    238. 

  238. 		for (i = 0; i < f->numparms; i++) {
    239. 

  239. 			for (j = 0; j < f->parm_size[i]; j++) {
    240. 

  240. 				memcpy (&pr->pr_globals[o],
    241. 

  241. 						&pr->pr_globals[OFS_PARM0 + i * 3 + j],
    242. 

  242. 						sizeof (pr_type_t));
    243. 

  243. 				o++;
    244. 

  244. 			}
    245. 

  245. 		}
    246. 

  246. 	} else {
    247. 

  247. 		pr_type_t  *argc = &pr->pr_globals[o++];
    248. 

  248. 		pr_type_t  *argv = &pr->pr_globals[o++];
    249. 

  249. 		for (i = 0; i < -f->numparms - 1; i++) {
    250. 

  250. 			for (j = 0; j < f->parm_size[i]; j++) {
    251. 

  251. 				memcpy (&pr->pr_globals[o],
    252. 

  252. 						&pr->pr_globals[OFS_PARM0 + i * 3 + j],
    253. 

  253. 						sizeof (pr_type_t));
    254. 

  254. 				o++;
    255. 

  255. 			}
    256. 

  256. 		}
    257. 

  257. 		argc->integer_var = pr->pr_argc - i;
    258. 

  258. 		argv->integer_var = o;
    259. 

  259. 		while (i < MAX_PARMS) {
    260. 

  260. 			memcpy (&pr->pr_globals[o],
    261. 

  261. 					&pr->pr_globals[OFS_PARM0 + i * 3],
    262. 

  262. 					3);
    263. 

  263. 			o += 3;
    264. 

  264. 			i++;
    265. 

  265. 		}
    266. 

  266. 	}
    267. 

  267. 

  268. 	pr->pr_xfunction = f;
    269. 

  269. 	return f->first_statement - 1;		// offset the s++
    270. 

  270. }
    271. 

  271. 

  272. int
    273. 

  273. PR_LeaveFunction (progs_t * pr)
    274. 

  274. {
    275. 

  275. 	int			c;
    276. 

  276. 

  277. 	if (pr->pr_depth <= 0)
    278. 

  278. 		PR_Error (pr, "prog stack underflow");
    279. 

  279. 

  280. 	// restore locals from the stack
    281. 

  281. 	c = pr->pr_xfunction->locals;
    282. 

  282. 	pr->localstack_used -= c;
    283. 

  283. 	if (pr->localstack_used < 0)
    284. 

  284. 		PR_RunError (pr, "PR_LeaveFunction: locals stack underflow");
    285. 

  285. 

  286. 	memcpy (&pr->pr_globals[pr->pr_xfunction->parm_start],
    287. 

  287. 			&pr->localstack[pr->localstack_used],
    288. 

  288. 			sizeof (pr_type_t) * c);
    289. 

  289. 

  290. 	// up stack
    291. 

  291. 	pr->pr_depth--;
    292. 

  292. 	pr->pr_xfunction = pr->pr_stack[pr->pr_depth].f;
    293. 

  293. 	return pr->pr_stack[pr->pr_depth].s;
    294. 

  294. }
    295. 

  295. 

  296. static void
    297. 

  297. signal_hook (int sig, void *data)
    298. 

  298. {
    299. 

  299. 	progs_t    *pr = (progs_t *) data;
    300. 

  300. 	PR_DumpState (pr);
    301. 

  301. }
    302. 

  302. 

  303. #define OPA (*op_a)
    304. 

  304. #define OPB (*op_b)
    305. 

  305. #define OPC (*op_c)
    306. 

  306. 

  307. /*
    308. 

  308. 	This gets around the problem of needing to test for -0.0 but denormals
    309. 

  309. 	causing exceptions (or wrong results for what we need) on the alpha.
    310. 

  310. */
    311. 

  311. #define FNZ(x) ((x).integer_var && (x).integer_var != 0x80000000)
    312. 

  312. 

  313. 

  314. /*
    315. 

  315. 	PR_ExecuteProgram
    316. 

    317. 

  317. 	The interpretation main loop
    318. 

  318. */
    319. 

  319. void
    320. 

  320. PR_ExecuteProgram (progs_t * pr, func_t fnum)
    321. 

  321. {
    322. 

  322. 	int				exitdepth, profile, startprofile;
    323. 

  323. 	int             pointer;
    324. 

  324. 	dfunction_t	   *f, *newf;
    325. 

  325. 	dstatement_t   *st;
    326. 

  326. 	edict_t		   *ed;
    327. 

  327. 	pr_type_t	   *ptr;
    328. 

  328. 

  329. 	if (!fnum || fnum >= pr->progs->numfunctions) {
    330. 

  330. 		if (*pr->globals.self)
    331. 

  331. 			ED_Print (pr, PROG_TO_EDICT (pr, *pr->globals.self));
    332. 

  332. 		PR_RunError (pr, "PR_ExecuteProgram: NULL function");
    333. 

  333. 	}
    334. 

  334. 

  335. 	f = &pr->pr_functions[fnum];
    336. 

  336. 	//Sys_Printf("%s:\n", PR_GetString(pr,f->s_name));
    337. 

  337. 

  338. 	pr->pr_trace = false;
    339. 

  339. 

  340. 	// make a stack frame
    341. 

  341. 	exitdepth = pr->pr_depth;
    342. 

  342. 

  343. 	st = &pr->pr_statements[PR_EnterFunction (pr, f)];
    344. 

  344. 	startprofile = profile = 0;
    345. 

  345. 

  346. 	Sys_PushSignalHook (signal_hook, pr);
    347. 

  347. 

  348. 	while (1) {
    349. 

  349. 		pr_type_t  *op_a, *op_b, *op_c;
    350. 

  350. 

  351. 		st++;
    352. 

  352. 		if (++profile > 1000000 && !pr->no_exec_limit) {
    353. 

  353. 			pr->pr_xstatement = st - pr->pr_statements;
    354. 

  354. 			PR_RunError (pr, "runaway loop error");
    355. 

  355. 		}
    356. 

  356. 

  357. 		op_a = pr->pr_globals + st->a;
    358. 

  358. 		op_b = pr->pr_globals + st->b;
    359. 

  359. 		op_c = pr->pr_globals + st->c;
    360. 

  360. 

  361. 		if (pr->pr_trace)
    362. 

  362. 			PR_PrintStatement (pr, st);
    363. 

  363. 

  364. 		switch (st->op) {
    365. 

  365. 			case OP_ADD_F:
    366. 

  366. 				OPC.float_var = OPA.float_var + OPB.float_var;
    367. 

  367. 				break;
    368. 

  368. 			case OP_ADD_V:
    369. 

  369. 				VectorAdd (OPA.vector_var, OPB.vector_var, OPC.vector_var);
    370. 

  370. 				break;
    371. 

  371. 			case OP_ADD_S:
    372. 

  372. 				{
    373. 

  373. 					char *a = PR_GetString (pr, OPA.string_var);
    374. 

  374. 					char *b = PR_GetString (pr, OPB.string_var);
    375. 

  375. 					int lena = strlen (a);
    376. 

  376. 					int size = lena + strlen (b) + 1;
    377. 

  377. 					char *c = Hunk_TempAlloc (size);
    378. 

  378. 					strcpy (c, a);
    379. 

  379. 					strcpy (c + lena, b);
    380. 

  380. 					OPC.string_var = PR_SetString (pr, c);
    381. 

  381. 				}
    382. 

  382. 				break;
    383. 

  383. 			case OP_SUB_F:
    384. 

  384. 				OPC.float_var = OPA.float_var - OPB.float_var;
    385. 

  385. 				break;
    386. 

  386. 			case OP_SUB_V:
    387. 

  387. 				VectorSubtract (OPA.vector_var, OPB.vector_var, OPC.vector_var);
    388. 

  388. 				break;
    389. 

  389. 			case OP_MUL_F:
    390. 

  390. 				OPC.float_var = OPA.float_var * OPB.float_var;
    391. 

  391. 				break;
    392. 

  392. 			case OP_MUL_V:
    393. 

  393. 				OPC.float_var = DotProduct (OPA.vector_var, OPB.vector_var);
    394. 

  394. 				break;
    395. 

  395. 			case OP_MUL_FV:
    396. 

  396. 				VectorScale (OPB.vector_var, OPA.float_var, OPC.vector_var);
    397. 

  397. 				break;
    398. 

  398. 			case OP_MUL_VF:
    399. 

  399. 				VectorScale (OPA.vector_var, OPB.float_var, OPC.vector_var);
    400. 

  400. 				break;
    401. 

  401. 			case OP_DIV_F:
    402. 

  402. 				OPC.float_var = OPA.float_var / OPB.float_var;
    403. 

  403. 				break;
    404. 

  404. 			case OP_BITAND:
    405. 

  405. 				OPC.float_var = (int) OPA.float_var & (int) OPB.float_var;
    406. 

  406. 				break;
    407. 

  407. 			case OP_BITOR:
    408. 

  408. 				OPC.float_var = (int) OPA.float_var | (int) OPB.float_var;
    409. 

  409. 				break;
    410. 

  410. 			case OP_BITXOR_F:
    411. 

  411. 				OPC.float_var = (int) OPA.float_var ^ (int) OPB.float_var;
    412. 

  412. 				break;
    413. 

  413. 			case OP_BITNOT_F:
    414. 

  414. 				OPC.float_var = ~ (int) OPA.float_var;
    415. 

  415. 				break;
    416. 

  416. 			case OP_SHL_F:
    417. 

  417. 				OPC.float_var = (int) OPA.float_var << (int) OPB.float_var;
    418. 

  418. 				break;
    419. 

  419. 			case OP_SHR_F:
    420. 

  420. 				OPC.float_var = (int) OPA.float_var >> (int) OPB.float_var;
    421. 

  421. 				break;
    422. 

  422. 			case OP_SHL_I:
    423. 

  423. 				OPC.integer_var = OPA.integer_var << OPB.integer_var;
    424. 

  424. 				break;
    425. 

  425. 			case OP_SHR_I:
    426. 

  426. 				OPC.integer_var = OPA.integer_var >> OPB.integer_var;
    427. 

  427. 				break;
    428. 

  428. 			case OP_GE_F:
    429. 

  429. 				OPC.float_var = OPA.float_var >= OPB.float_var;
    430. 

  430. 				break;
    431. 

  431. 			case OP_LE_F:
    432. 

  432. 				OPC.float_var = OPA.float_var <= OPB.float_var;
    433. 

  433. 				break;
    434. 

  434. 			case OP_GT_F:
    435. 

  435. 				OPC.float_var = OPA.float_var > OPB.float_var;
    436. 

  436. 				break;
    437. 

  437. 			case OP_LT_F:
    438. 

  438. 				OPC.float_var = OPA.float_var < OPB.float_var;
    439. 

  439. 				break;
    440. 

  440. 			case OP_AND:	// OPA and OPB have to be float for -0.0
    441. 

  441. 				OPC.integer_var = FNZ (OPA) && FNZ (OPB);
    442. 

  442. 				break;
    443. 

  443. 			case OP_OR:		// OPA and OPB have to be float for -0.0
    444. 

  444. 				OPC.integer_var = FNZ (OPA) || FNZ (OPB);
    445. 

  445. 				break;
    446. 

  446. 			case OP_NOT_F:
    447. 

  447. 				OPC.integer_var = !FNZ (OPA);
    448. 

  448. 				break;
    449. 

  449. 			case OP_NOT_V:
    450. 

  450. 				OPC.integer_var = VectorIsZero (OPA.vector_var);
    451. 

  451. 				break;
    452. 

  452. 			case OP_NOT_S:
    453. 

  453. 				OPC.integer_var = !OPA.string_var ||
    454. 

  454. 					!*PR_GetString (pr, OPA.string_var);
    455. 

  455. 				break;
    456. 

  456. 			case OP_NOT_FNC:
    457. 

  457. 				OPC.integer_var = !OPA.func_var;
    458. 

  458. 				break;
    459. 

  459. 			case OP_NOT_ENT:
    460. 

  460. 				OPC.integer_var = !OPA.entity_var;
    461. 

  461. 				break;
    462. 

  462. 			case OP_EQ_F:
    463. 

  463. 				OPC.integer_var = OPA.float_var == OPB.float_var;
    464. 

  464. 				break;
    465. 

  465. 			case OP_EQ_V:
    466. 

  466. 				OPC.integer_var = VectorCompare (OPA.vector_var,
    467. 

  467. 												 OPB.vector_var);
    468. 

  468. 				break;
    469. 

  469. 			case OP_EQ_E:
    470. 

  470. 				OPC.integer_var = OPA.integer_var == OPB.integer_var;
    471. 

  471. 				break;
    472. 

  472. 			case OP_EQ_FNC:
    473. 

  473. 				OPC.integer_var = OPA.func_var == OPB.func_var;
    474. 

  474. 				break;
    475. 

  475. 			case OP_NE_F:
    476. 

  476. 				OPC.integer_var = OPA.float_var != OPB.float_var;
    477. 

  477. 				break;
    478. 

  478. 			case OP_NE_V:
    479. 

  479. 				OPC.integer_var = !VectorCompare (OPA.vector_var,
    480. 

  480. 												  OPB.vector_var);
    481. 

  481. 				break;
    482. 

  482. 			case OP_LE_S:
    483. 

  483. 			case OP_GE_S:
    484. 

  484. 			case OP_LT_S:
    485. 

  485. 			case OP_GT_S:
    486. 

  486. 			case OP_NE_S:
    487. 

  487. 			case OP_EQ_S:
    488. 

  488. 				{
    489. 

  489. 					int cmp = strcmp (PR_GetString (pr, OPA.string_var),
    490. 

  490. 									  PR_GetString (pr, OPB.string_var));
    491. 

  491. 					switch (st->op) {
    492. 

  492. 						case OP_LE_S: cmp = (cmp <= 0); break;
    493. 

  493. 						case OP_GE_S: cmp = (cmp >= 0); break;
    494. 

  494. 						case OP_LT_S: cmp = (cmp < 0); break;
    495. 

  495. 						case OP_GT_S: cmp = (cmp > 0); break;
    496. 

  496. 						case OP_NE_S: break;
    497. 

  497. 						case OP_EQ_S: cmp = !cmp; break;
    498. 

  498. 						default:      break;
    499. 

  499. 					}
    500. 

  500. 					OPC.integer_var = cmp;
    501. 

  501. 				}
    502. 

  502. 				break;
    503. 

  503. 			case OP_NE_E:
    504. 

  504. 				OPC.integer_var = OPA.integer_var != OPB.integer_var;
    505. 

  505. 				break;
    506. 

  506. 			case OP_NE_FNC:
    507. 

  507. 				OPC.integer_var = OPA.func_var != OPB.func_var;
    508. 

  508. 				break;
    509. 

  509. 

  510. 			// ==================
    511. 

  511. 			case OP_STORE_F:
    512. 

  512. 			case OP_STORE_ENT:
    513. 

  513. 			case OP_STORE_FLD:			// integers
    514. 

  514. 			case OP_STORE_S:
    515. 

  515. 			case OP_STORE_FNC:			// pointers
    516. 

  516. 			case OP_STORE_I:
    517. 

  517. 			case OP_STORE_P:
    518. 

  518. 				OPB.integer_var = OPA.integer_var;
    519. 

  519. 				break;
    520. 

  520. 			case OP_STORE_V:
    521. 

  521. 				VectorCopy (OPA.vector_var, OPB.vector_var);
    522. 

  522. 				break;
    523. 

  523. 

  524. 			case OP_STOREP_F:
    525. 

  525. 			case OP_STOREP_ENT:
    526. 

  526. 			case OP_STOREP_FLD:		// integers
    527. 

  527. 			case OP_STOREP_S:
    528. 

  528. 			case OP_STOREP_FNC:		// pointers
    529. 

  529. 			case OP_STOREP_I:
    530. 

  530. 			case OP_STOREP_P:
    531. 

  531. 				//FIXME put bounds checking back
    532. 

  532. 				ptr = pr->pr_globals + OPB.integer_var;
    533. 

  533. 				ptr->integer_var = OPA.integer_var;
    534. 

  534. 				break;
    535. 

  535. 			case OP_STOREP_V:
    536. 

  536. 				//FIXME put bounds checking back
    537. 

  537. 				ptr = pr->pr_globals + OPB.integer_var;
    538. 

  538. 				VectorCopy (OPA.vector_var, ptr->vector_var);
    539. 

  539. 				break;
    540. 

  540. 

  541. 			case OP_ADDRESS:
    542. 

  542. 				if (pr_boundscheck->int_val
    543. 

  543. 					&& (OPA.entity_var < 0 || OPA.entity_var >=
    544. 

  544. 						pr->pr_edictareasize)) {
    545. 

  545. 					pr->pr_xstatement = st - pr->pr_statements;
    546. 

  546. 					PR_RunError (pr, "Progs attempted to address an out of "
    547. 

  547. 								 "bounds edict");
    548. 

  548. 				}
    549. 

  549. 				if (pr_boundscheck->int_val
    550. 

  550. 					&& (OPA.entity_var == 0 && pr->null_bad)) {
    551. 

  551. 					pr->pr_xstatement = st - pr->pr_statements;
    552. 

  552. 					PR_RunError (pr, "assignment to world entity");
    553. 

  553. 				}
    554. 

  554. 				if (pr_boundscheck->int_val
    555. 

  555. 					&& (OPB.integer_var < 0 || OPB.integer_var >=
    556. 

  556. 						pr->progs->entityfields)) {
    557. 

  557. 					pr->pr_xstatement = st - pr->pr_statements;
    558. 

  558. 					PR_RunError (pr, "Progs attempted to address an invalid "
    559. 

  559. 								 "field in an edict");
    560. 

  560. 				}
    561. 

  561. 				ed = PROG_TO_EDICT (pr, OPA.entity_var);
    562. 

  562. 				OPC.integer_var = &ed->v[OPB.integer_var] - pr->pr_globals;
    563. 

  563. 				break;
    564. 

  564. 			case OP_ADDRESS_F:
    565. 

  565. 			case OP_ADDRESS_V:
    566. 

  566. 			case OP_ADDRESS_S:
    567. 

  567. 			case OP_ADDRESS_ENT:
    568. 

  568. 			case OP_ADDRESS_FLD:
    569. 

  569. 			case OP_ADDRESS_FNC:
    570. 

  570. 			case OP_ADDRESS_I:
    571. 

  571. 			case OP_ADDRESS_P:
    572. 

  572. 				OPC.integer_var = st->a;
    573. 

  573. 				break;
    574. 

  574. 

  575. 			case OP_LOAD_F:
    576. 

  576. 			case OP_LOAD_FLD:
    577. 

  577. 			case OP_LOAD_ENT:
    578. 

  578. 			case OP_LOAD_S:
    579. 

  579. 			case OP_LOAD_FNC:
    580. 

  580. 			case OP_LOAD_I:
    581. 

  581. 			case OP_LOAD_P:
    582. 

  582. 				if (pr_boundscheck->int_val
    583. 

  583. 					&& (OPA.entity_var < 0 || OPA.entity_var >=
    584. 

  584. 						pr->pr_edictareasize)) {
    585. 

  585. 					pr->pr_xstatement = st - pr->pr_statements;
    586. 

  586. 					PR_RunError (pr, "Progs attempted to read an out of "
    587. 

  587. 								 "bounds edict number");
    588. 

  588. 				}
    589. 

  589. 				if (pr_boundscheck->int_val
    590. 

  590. 					&& (OPB.integer_var < 0 || OPB.integer_var >=
    591. 

  591. 						pr->progs->entityfields)) {
    592. 

  592. 					pr->pr_xstatement = st - pr->pr_statements;
    593. 

  593. 					PR_RunError (pr, "Progs attempted to read an invalid "
    594. 

  594. 								 "field in an edict");
    595. 

  595. 				}
    596. 

  596. 				ed = PROG_TO_EDICT (pr, OPA.entity_var);
    597. 

  597. 				OPC.integer_var = ed->v[OPB.integer_var].integer_var;
    598. 

  598. 				break;
    599. 

  599. 			case OP_LOAD_V:
    600. 

  600. 				if (pr_boundscheck->int_val
    601. 

  601. 					&& (OPA.entity_var < 0 || OPA.entity_var >=
    602. 

  602. 						pr->pr_edictareasize)) {
    603. 

  603. 					pr->pr_xstatement = st - pr->pr_statements;
    604. 

  604. 					PR_RunError (pr, "Progs attempted to read an out of "
    605. 

  605. 								 "bounds edict number");
    606. 

  606. 				}
    607. 

  607. 				if (pr_boundscheck->int_val
    608. 

  608. 					&& (OPB.integer_var < 0
    609. 

  609. 						|| OPB.integer_var + 2 >= pr->progs->entityfields)) {
    610. 

  610. 					pr->pr_xstatement = st - pr->pr_statements;
    611. 

  611. 					PR_RunError (pr, "Progs attempted to read an invalid "
    612. 

  612. 								 "field in an edict");
    613. 

  613. 				}
    614. 

  614. 				ed = PROG_TO_EDICT (pr, OPA.entity_var);
    615. 

  615. 				memcpy (&OPC, &ed->v[OPB.integer_var], 3 * sizeof (OPC));
    616. 

  616. 				break;
    617. 

  617. 

  618. 			case OP_LOADB_F:
    619. 

  619. 			case OP_LOADB_S:
    620. 

  620. 			case OP_LOADB_ENT:
    621. 

  621. 			case OP_LOADB_FLD:
    622. 

  622. 			case OP_LOADB_FNC:
    623. 

  623. 			case OP_LOADB_I:
    624. 

  624. 			case OP_LOADB_P:
    625. 

  625. 				//FIXME put bounds checking in
    626. 

  626. 				pointer = OPA.integer_var + OPB.integer_var;
    627. 

  627. 				ptr = pr->pr_globals + pointer;
    628. 

  628. 				OPC.integer_var = ptr->integer_var;
    629. 

  629. 				break;
    630. 

  630. 			case OP_LOADB_V:
    631. 

  631. 				//FIXME put bounds checking in
    632. 

  632. 				pointer = OPA.integer_var + OPB.integer_var;
    633. 

  633. 				ptr = pr->pr_globals + pointer;
    634. 

  634. 				VectorCopy (ptr->vector_var, OPC.vector_var);
    635. 

  635. 				break;
    636. 

  636. 

  637. 			case OP_LOADBI_F:
    638. 

  638. 			case OP_LOADBI_S:
    639. 

  639. 			case OP_LOADBI_ENT:
    640. 

  640. 			case OP_LOADBI_FLD:
    641. 

  641. 			case OP_LOADBI_FNC:
    642. 

  642. 			case OP_LOADBI_I:
    643. 

  643. 			case OP_LOADBI_P:
    644. 

  644. 				//FIXME put bounds checking in
    645. 

  645. 				pointer = OPA.integer_var + (short) st->b;
    646. 

  646. 				ptr = pr->pr_globals + pointer;
    647. 

  647. 				OPC.integer_var = ptr->integer_var;
    648. 

  648. 				break;
    649. 

  649. 			case OP_LOADBI_V:
    650. 

  650. 				//FIXME put bounds checking in
    651. 

  651. 				pointer = OPA.integer_var + (short) st->b;
    652. 

  652. 				ptr = pr->pr_globals + pointer;
    653. 

  653. 				VectorCopy (ptr->vector_var, OPC.vector_var);
    654. 

  654. 				break;
    655. 

  655. 

  656. 			case OP_LEA:
    657. 

  657. 				pointer = OPA.integer_var + OPB.integer_var;
    658. 

  658. 				OPC.integer_var = pointer;
    659. 

  659. 				break;
    660. 

  660. 

  661. 			case OP_LEAI:
    662. 

  662. 				pointer = OPA.integer_var + (short) st->b;
    663. 

  663. 				OPC.integer_var = pointer;
    664. 

  664. 				break;
    665. 

  665. 

  666. 			case OP_STOREB_F:
    667. 

  667. 			case OP_STOREB_S:
    668. 

  668. 			case OP_STOREB_ENT:
    669. 

  669. 			case OP_STOREB_FLD:
    670. 

  670. 			case OP_STOREB_FNC:
    671. 

  671. 			case OP_STOREB_I:
    672. 

  672. 			case OP_STOREB_P:
    673. 

  673. 				//FIXME put bounds checking in
    674. 

  674. 				pointer = OPB.integer_var + OPC.integer_var;
    675. 

  675. 				ptr = pr->pr_globals + pointer;
    676. 

  676. 				ptr->integer_var = OPA.integer_var;
    677. 

  677. 				break;
    678. 

  678. 			case OP_STOREB_V:
    679. 

  679. 				//FIXME put bounds checking in
    680. 

  680. 				pointer = OPB.integer_var + OPC.integer_var;
    681. 

  681. 				ptr = pr->pr_globals + pointer;
    682. 

  682. 				VectorCopy (OPA.vector_var, ptr->vector_var);
    683. 

  683. 				break;
    684. 

  684. 

  685. 			case OP_STOREBI_F:
    686. 

  686. 			case OP_STOREBI_S:
    687. 

  687. 			case OP_STOREBI_ENT:
    688. 

  688. 			case OP_STOREBI_FLD:
    689. 

  689. 			case OP_STOREBI_FNC:
    690. 

  690. 			case OP_STOREBI_I:
    691. 

  691. 			case OP_STOREBI_P:
    692. 

  692. 				//FIXME put bounds checking in
    693. 

  693. 				pointer = OPB.integer_var + (short) st->c;
    694. 

  694. 				ptr = pr->pr_globals + pointer;
    695. 

  695. 				ptr->integer_var = OPA.integer_var;
    696. 

  696. 				break;
    697. 

  697. 			case OP_STOREBI_V:
    698. 

  698. 				//FIXME put bounds checking in
    699. 

  699. 				pointer = OPB.integer_var + (short) st->c;
    700. 

  700. 				ptr = pr->pr_globals + pointer;
    701. 

  701. 				VectorCopy (OPA.vector_var, ptr->vector_var);
    702. 

  702. 				break;
    703. 

  703. 

  704. 			// ==================
    705. 

  705. 			case OP_IFNOT:
    706. 

  706. 				if (!OPA.integer_var)
    707. 

  707. 					st += (short)st->b - 1;		// offset the s++
    708. 

  708. 				break;
    709. 

  709. 			case OP_IF:
    710. 

  710. 				if (OPA.integer_var)
    711. 

  711. 					st += (short)st->b - 1;		// offset the s++
    712. 

  712. 				break;
    713. 

  713. 			case OP_IFBE:
    714. 

  714. 				if (OPA.integer_var <= 0)
    715. 

  715. 					st += (short)st->b - 1;		// offset the s++
    716. 

  716. 				break;
    717. 

  717. 			case OP_IFB:
    718. 

  718. 				if (OPA.integer_var < 0)
    719. 

  719. 					st += (short)st->b - 1;		// offset the s++
    720. 

  720. 				break;
    721. 

  721. 			case OP_IFAE:
    722. 

  722. 				if (OPA.integer_var >= 0)
    723. 

  723. 					st += (short)st->b - 1;		// offset the s++
    724. 

  724. 				break;
    725. 

  725. 			case OP_IFA:
    726. 

  726. 				if (OPA.integer_var > 0)
    727. 

  727. 					st += (short)st->b - 1;		// offset the s++
    728. 

  728. 				break;
    729. 

  729. 			case OP_GOTO:
    730. 

  730. 				st += (short)st->a - 1;			// offset the s++
    731. 

  731. 				break;
    732. 

  732. 			case OP_JUMP:
    733. 

  733. 				if (pr_boundscheck->int_val
    734. 

  734. 					&& (OPA.uinteger_var >= pr->progs->numstatements)) {
    735. 

  735. 					pr->pr_xstatement = st - pr->pr_statements;
    736. 

  736. 					PR_RunError (pr, "Invalid jump destination");
    737. 

  737. 				}
    738. 

  738. 				st = &pr->pr_statements[OPA.uinteger_var];
    739. 

  739. 				break;
    740. 

  740. 			case OP_JUMPB:
    741. 

  741. 				//FIXME put bounds checking in
    742. 

  742. 				pointer = OPA.integer_var + OPB.integer_var;
    743. 

  743. 				ptr = pr->pr_globals + pointer;
    744. 

  744. 				pointer = ptr->integer_var;
    745. 

  745. 				if (pr_boundscheck->int_val
    746. 

  746. 					&& (pointer >= pr->progs->numstatements)) {
    747. 

  747. 					pr->pr_xstatement = st - pr->pr_statements;
    748. 

  748. 					PR_RunError (pr, "Invalid jump destination");
    749. 

  749. 				}
    750. 

  750. 				st = &pr->pr_statements[pointer];
    751. 

  751. 				break;
    752. 

  752. 

  753. 			case OP_CALL0:
    754. 

  754. 			case OP_CALL1:
    755. 

  755. 			case OP_CALL2:
    756. 

  756. 			case OP_CALL3:
    757. 

  757. 			case OP_CALL4:
    758. 

  758. 			case OP_CALL5:
    759. 

  759. 			case OP_CALL6:
    760. 

  760. 			case OP_CALL7:
    761. 

  761. 			case OP_CALL8:
    762. 

  762. 				pr->pr_xfunction->profile += profile - startprofile;
    763. 

  763. 				startprofile = profile;
    764. 

  764. 				pr->pr_xstatement = st - pr->pr_statements;
    765. 

  765. 				pr->pr_argc = st->op - OP_CALL0;
    766. 

  766. 				if (!OPA.func_var)
    767. 

  767. 					PR_RunError (pr, "NULL function");
    768. 

  768. 				newf = &pr->pr_functions[OPA.func_var];
    769. 

  769. 				if (newf->first_statement < 0) {
    770. 

  770. 					// negative statements are built in functions
    771. 

  771. 					int         i = -newf->first_statement;
    772. 

  772. 

  773. 					if (i >= pr->numbuiltins || !pr->builtins[i]
    774. 

  774. 						|| !pr->builtins[i]->proc)
    775. 

  775. 						PR_RunError (pr, "Bad builtin call number");
    776. 

  776. 					pr->builtins[i]->proc (pr);
    777. 

  777. 					break;
    778. 

  778. 				}
    779. 

  779. 

  780. 				st = &pr->pr_statements[PR_EnterFunction (pr, newf)];
    781. 

  781. 				break;
    782. 

  782. 			case OP_DONE:
    783. 

  783. 			case OP_RETURN:
    784. 

  784. 				memcpy (&pr->pr_globals[OFS_RETURN], &OPA, 3 * sizeof (OPA));
    785. 

  785. 				st = &pr->pr_statements[PR_LeaveFunction (pr)];
    786. 

  786. 				if (pr->pr_depth == exitdepth) {
    787. 

  787. 					Sys_PopSignalHook ();
    788. 

  788. 					return;					// all done
    789. 

  789. 				}
    790. 

  790. 				break;
    791. 

  791. 			case OP_STATE:
    792. 

  792. 				ed = PROG_TO_EDICT (pr, *pr->globals.self);
    793. 

  793. 				ed->v[pr->fields.nextthink].float_var = *pr->globals.time +
    794. 

  794. 					0.1;
    795. 

  795. 				ed->v[pr->fields.frame].float_var = OPA.float_var;
    796. 

  796. 				ed->v[pr->fields.think].func_var = OPB.func_var;
    797. 

  797. 				break;
    798. 

  798. 			case OP_ADD_I:
    799. 

  799. 				OPC.integer_var = OPA.integer_var + OPB.integer_var;
    800. 

  800. 				break;
    801. 

  801. 			case OP_SUB_I:
    802. 

  802. 				OPC.integer_var = OPA.integer_var - OPB.integer_var;
    803. 

  803. 				break;
    804. 

  804. 			case OP_MUL_I:
    805. 

  805. 				OPC.integer_var = OPA.integer_var * OPB.integer_var;
    806. 

  806. 				break;
    807. 

  807. /*
    808. 

  808. 			case OP_DIV_VF:
    809. 

  809. 				{
    810. 

  810. 					float       temp = 1.0f / OPB.float_var;
    811. 

  811. 					VectorScale (OPA.vector_var, temp, OPC.vector_var);
    812. 

  812. 				}
    813. 

  813. 				break;
    814. 

  814. */
    815. 

  815. 			case OP_DIV_I:
    816. 

  816. 				OPC.integer_var = OPA.integer_var / OPB.integer_var;
    817. 

  817. 				break;
    818. 

  818. 			case OP_MOD_I:
    819. 

  819. 				OPC.integer_var = OPA.integer_var % OPB.integer_var;
    820. 

  820. 				break;
    821. 

  821. 			case OP_MOD_F:
    822. 

  822. 				OPC.float_var = (int) OPA.float_var % (int) OPB.float_var;
    823. 

  823. 				break;
    824. 

  824. 			case OP_CONV_IF:
    825. 

  825. 				OPC.float_var = OPA.integer_var;
    826. 

  826. 				break;
    827. 

  827. 			case OP_CONV_FI:
    828. 

  828. 				OPC.integer_var = OPA.float_var;
    829. 

  829. 				break;
    830. 

  830. 			case OP_BITAND_I:
    831. 

  831. 				OPC.integer_var = OPA.integer_var & OPB.integer_var;
    832. 

  832. 				break;
    833. 

  833. 			case OP_BITOR_I:
    834. 

  834. 				OPC.integer_var = OPA.integer_var | OPB.integer_var;
    835. 

  835. 				break;
    836. 

  836. 			case OP_BITXOR_I:
    837. 

  837. 				OPC.integer_var = OPA.integer_var ^ OPB.integer_var;
    838. 

  838. 				break;
    839. 

  839. 			case OP_BITNOT_I:
    840. 

  840. 				OPC.integer_var = ~OPA.integer_var;
    841. 

  841. 				break;
    842. 

  842. 

  843. 			case OP_GE_I:
    844. 

  844. 			case OP_GE_P:
    845. 

  845. 				OPC.integer_var = OPA.integer_var >= OPB.integer_var;
    846. 

  846. 				break;
    847. 

  847. 			case OP_LE_I:
    848. 

  848. 			case OP_LE_P:
    849. 

  849. 				OPC.integer_var = OPA.integer_var <= OPB.integer_var;
    850. 

  850. 				break;
    851. 

  851. 			case OP_GT_I:
    852. 

  852. 			case OP_GT_P:
    853. 

  853. 				OPC.integer_var = OPA.integer_var > OPB.integer_var;
    854. 

  854. 				break;
    855. 

  855. 			case OP_LT_I:
    856. 

  856. 			case OP_LT_P:
    857. 

  857. 				OPC.integer_var = OPA.uinteger_var < OPB.uinteger_var;
    858. 

  858. 				break;
    859. 

  859. 			case OP_GE_UI:
    860. 

  860. 				OPC.integer_var = OPA.uinteger_var >= OPB.uinteger_var;
    861. 

  861. 				break;
    862. 

  862. 			case OP_LE_UI:
    863. 

  863. 				OPC.integer_var = OPA.uinteger_var <= OPB.uinteger_var;
    864. 

  864. 				break;
    865. 

  865. 			case OP_GT_UI:
    866. 

  866. 				OPC.integer_var = OPA.uinteger_var > OPB.uinteger_var;
    867. 

  867. 				break;
    868. 

  868. 			case OP_LT_UI:
    869. 

  869. 				OPC.integer_var = OPA.integer_var < OPB.integer_var;
    870. 

  870. 				break;
    871. 

  871. 

  872. 			case OP_AND_I:
    873. 

  873. 				OPC.integer_var = OPA.integer_var && OPB.integer_var;
    874. 

  874. 				break;
    875. 

  875. 			case OP_OR_I:
    876. 

  876. 				OPC.integer_var = OPA.integer_var || OPB.integer_var;
    877. 

  877. 				break;
    878. 

  878. 			case OP_NOT_I:
    879. 

  879. 			case OP_NOT_P:
    880. 

  880. 				OPC.integer_var = !OPA.integer_var;
    881. 

  881. 				break;
    882. 

  882. 			case OP_EQ_I:
    883. 

  883. 			case OP_EQ_P:
    884. 

  884. 				OPC.integer_var = OPA.integer_var == OPB.integer_var;
    885. 

  885. 				break;
    886. 

  886. 			case OP_NE_I:
    887. 

  887. 			case OP_NE_P:
    888. 

  888. 				OPC.integer_var = OPA.integer_var != OPB.integer_var;
    889. 

  889. 				break;
    890. 

  890. 

  891. // LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized
    892. 

  892. /*
    893. 

  893. 			case OP_BOUNDCHECK:
    894. 

  894. 				if (OPA.integer_var < 0 || OPA.integer_var >= st->b) {
    895. 

  895. 					pr->pr_xstatement = st - pr->pr_statements;
    896. 

  896. 					PR_RunError (pr, "Progs boundcheck failed at line number "
    897. 

  897. 					"%d, value is < 0 or >= %d", st->b, st->c);
    898. 

  898. 				}
    899. 

  899. 				break;
    900. 

    901. 

  901. */
    902. 

  902. 			default:
    903. 

  903. 				pr->pr_xstatement = st - pr->pr_statements;
    904. 

  904. 				PR_RunError (pr, "Bad opcode %i", st->op);
    905. 

  905. 		}
    906. 

  906. 	}
    907. 

  907. }
    908. 

  908.