#define PROGSUSED
#include "progsint.h"
//#include "editor.h"

#define HunkAlloc BADGDFG sdfhhsf FHS


#define Host_Error Sys_Error


//=============================================================================

/*
=================
PR_PrintStatement
=================
*/
/*
void PR_PrintStatement (progfuncs_t *progfuncs, dstatement16_t *s)
{
	int		i;
printf("PR_PrintStatement is unsupported\n");
return;
	if ( (unsigned)s->op < OP_NUMOPS)
	{
		printf ("%s ",  pr_opcodes[s->op].name);
		i = strlen(pr_opcodes[s->op].name);
		for ( ; i<10 ; i++)
			printf (" ");
	}
		
	if (s->op == OP_IF || s->op == OP_IFNOT)
		printf ("%sbranch %i",PR_GlobalString(progfuncs, s->a),s->b);
	else if (s->op == OP_GOTO)
	{
		printf ("branch %i",s->a);
	}
	else if ( (unsigned)(s->op - OP_STORE_F) < 6)
	{
		printf ("%s",PR_GlobalString(progfuncs, s->a));
		printf ("%s", PR_GlobalStringNoContents(progfuncs, s->b));
	}
	else
	{
		if (s->a)
			printf ("%s",PR_GlobalString(progfuncs, s->a));
		if (s->b)
			printf ("%s",PR_GlobalString(progfuncs, s->b));
		if (s->c)
			printf ("%s", PR_GlobalStringNoContents(progfuncs, s->c));
	}
	printf ("\n");
}
*/

/*
============
PR_StackTrace
============
*/
char *QC_ucase(char *str)
{
	static char s[1024];
	strcpy(s, str);
	str = s;

	while(*str)
	{
		if (*str >= 'a' && *str <= 'z')
			*str = *str - 'a' + 'A';
		str++;
	}
	return s;
}

void PR_StackTrace (progfuncs_t *progfuncs)
{
	dfunction_t	*f;
	int			i;
	int progs;

#ifdef STACKTRACE
	int arg;
	int *globalbase;
#endif
	progs = -1;
	
	if (pr_depth == 0)
	{
		printf ("<NO STACK>\n");
		return;
	}
	
#ifdef STACKTRACE
	globalbase = (int *)pr_globals + pr_xfunction->parm_start - pr_xfunction->locals;
#endif

	pr_stack[pr_depth].f = pr_xfunction;
	pr_stack[pr_depth].s = pr_xstatement;
	for (i=pr_depth ; i>0 ; i--)
	{
		f = pr_stack[i].f;
		
		if (!f)
		{
			printf ("<NO FUNCTION>\n");
		}
		else
		{
			if (pr_stack[i].progsnum != progs)
			{
				progs = pr_stack[i].progsnum;

				printf ("<%s>\n", pr_progstate[progs].filename);
			}
			if (!f->s_file)
				printf ("stripped     : %s\n", f->s_name+progfuncs->stringtable);
			else
			{
				if (pr_progstate[progs].linenums)
					printf ("%12s %i : %s\n", f->s_file+progfuncs->stringtable, pr_progstate[progs].linenums[pr_stack[i].s], f->s_name+progfuncs->stringtable);
				else
					printf ("%12s : %s\n", f->s_file+progfuncs->stringtable, f->s_name+progfuncs->stringtable);
			}

#ifdef STACKTRACE

			for (arg = 0; arg < f->locals; arg++)
			{
				ddef16_t *local;
				local = ED_GlobalAtOfs16(progfuncs, f->parm_start+arg);
				if (!local)
				{
					printf("    ofs %i: %f : %i\n", f->parm_start+arg, *(float *)(globalbase - f->locals+arg), *(int *)(globalbase - f->locals+arg) );
				}
				else
				{
					printf("    %s: %s\n", local->s_name+progfuncs->stringtable, PR_ValueString(progfuncs, local->type, (eval_t*)(globalbase - f->locals+arg)));
					if (local->type == ev_vector)
						arg+=2;
				}
			}

			if (i == pr_depth)
				globalbase = localstack + localstack_used;
			else
				globalbase -= f->locals;
#endif
		}
	}
}

/*
============
PR_Profile_f

============
*/
/*
void PR_Profile_f (void)
{
	dfunction_t	*f, *best;
	int			max;
	int			num;
	unsigned int			i;

	num = 0;
	do
	{
		max = 0;
		best = NULL;
		for (i=0 ; i<pr_progs->numfunctions ; i++)
		{
			f = &pr_functions[i];
			if (f->profile > max && f->first_statement >=0)
			{
				max = f->profile;
				best = f;
			}
		}
		if (best)
		{
			if (num < 10)
				printf ("%7i %s\n", best->profile, best->s_name);
			num++;
			best->profile = 0;
		}
	} while (best);
}
*/


/*
============
PR_RunError

Aborts the currently executing function
============
*/
void VARGS PR_RunError (progfuncs_t *progfuncs, char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,error);
	Q_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

//	{
//		void SV_EndRedirect (void);
//		SV_EndRedirect();
//	}

//	PR_PrintStatement (pr_statements + pr_xstatement);
	PR_StackTrace (progfuncs);
	printf ("\n");

//editbadfile(pr_strings + pr_xfunction->s_file, -1);
	
//	pr_depth = 0;		// dump the stack so host_error can shutdown functions	
//	prinst->exitdepth = 0;

	Abort ("%s", string);
}

/*
============================================================================
PR_ExecuteProgram

The interpretation main loop
============================================================================
*/

/*
====================
PR_EnterFunction

Returns the new program statement counter
====================
*/
void	PR_AbortStack			(progfuncs_t *progfuncs);
int PR_EnterFunction (progfuncs_t *progfuncs, dfunction_t *f, int progsnum)
{
	int		i, j, c, o;

	pr_stack[pr_depth].s = pr_xstatement;
	pr_stack[pr_depth].f = pr_xfunction;	
	pr_stack[pr_depth].progsnum = progsnum;
	pr_stack[pr_depth].pushed = pr_spushed;
	pr_depth++;
	if (pr_depth == MAX_STACK_DEPTH)
	{
		pr_depth--;
		PR_StackTrace (progfuncs);

		printf ("stack overflow on call to %s\n", progfuncs->stringtable+f->s_name);

		//comment this out if you want the progs to try to continue anyway (could cause infinate loops)
		PR_AbortStack(progfuncs);
		Abort("Stack Overflow in %s\n", progfuncs->stringtable+f->s_name);
		return pr_xstatement;
	}

	localstack_used += pr_spushed;	//make sure the call doesn't hurt pushed pointers

// save off any locals that the new function steps on (to a side place, fromwhere they are restored on exit)
	c = f->locals;
	if (localstack_used + c > LOCALSTACK_SIZE)
	{
		localstack_used -= pr_spushed;
		pr_depth--;
		PR_RunError (progfuncs, "PR_ExecuteProgram: locals stack overflow\n");
	}

	for (i=0 ; i < c ; i++)
		localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
	localstack_used += c;

// copy parameters (set initial values)
	o = f->parm_start;
	for (i=0 ; i<f->numparms ; i++)
	{
		for (j=0 ; j<f->parm_size[i] ; j++)
		{
			((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j];
			o++;
		}
	}

	pr_xfunction = f;
	return f->first_statement - 1;	// offset the s++
}

/*
====================
PR_LeaveFunction
====================
*/
int PR_LeaveFunction (progfuncs_t *progfuncs)
{
	int		i, c;

	if (pr_depth <= 0)
		Sys_Error ("prog stack underflow");

// restore locals from the stack
	c = pr_xfunction->locals;
	localstack_used -= c;
	if (localstack_used < 0)
		PR_RunError (progfuncs, "PR_ExecuteProgram: locals stack underflow\n");

	for (i=0 ; i < c ; i++)
		((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];

// up stack
	pr_depth--;
	PR_MoveParms(progfuncs, pr_stack[pr_depth].progsnum, pr_typecurrent);
	PR_SwitchProgs(progfuncs, pr_stack[pr_depth].progsnum);
	pr_xfunction = pr_stack[pr_depth].f;
	pr_spushed = pr_stack[pr_depth].pushed;

	localstack_used -= pr_spushed;
	return pr_stack[pr_depth].s;
}

ddef32_t *ED_FindLocalOrGlobal(progfuncs_t *progfuncs, char *name, eval_t **val)
{
	static ddef32_t def;
	ddef32_t *def32;
	ddef16_t *def16;
	int i;

	switch (pr_progstate[pr_typecurrent].intsize)
	{
	case 16:
	case 24:
		//this gets parms fine, but not locals
		if (pr_xfunction)
		for (i = 0; i < pr_xfunction->numparms; i++)
		{
			def16 = ED_GlobalAtOfs16(progfuncs, pr_xfunction->parm_start+i);
			if (!def16)
				continue;
			if (!strcmp(def16->s_name+progfuncs->stringtable, name))
			{
				*val = (eval_t *)&pr_progstate[pr_typecurrent].globals[pr_xfunction->parm_start+i];

				//we need something like this for functions that are not the top layer
	//			*val = (eval_t *)&localstack[localstack_used-pr_xfunction->numparms*4];
				def.ofs = def16->ofs;
				def.s_name = def16->s_name;
				def.type = def16->type;
				return &def;
			}
		}
		def16 = ED_FindGlobal16(progfuncs, name);
		if (!def16)
			return NULL;
		def.ofs = def16->ofs;
		def.type = def16->type;
		def.s_name = def16->s_name;
		def32 = &def;
		break;
	case 32:
		//this gets parms fine, but not locals
		if (pr_xfunction)
		for (i = 0; i < pr_xfunction->numparms; i++)
		{
			def32 = ED_GlobalAtOfs32(progfuncs, pr_xfunction->parm_start+i);
			if (!def32)
				continue;
			if (!strcmp(def32->s_name+progfuncs->stringtable, name))
			{
				*val = (eval_t *)&pr_progstate[pr_typecurrent].globals[pr_xfunction->parm_start+i];

				//we need something like this for functions that are not the top layer
	//			*val = (eval_t *)&localstack[localstack_used-pr_xfunction->numparms*4];
				return def32;
			}
		}
		def32 = ED_FindGlobal32(progfuncs, name);
		if (!def32)
			return NULL;
		break;
	default:
		Sys_Error("Bad int size in ED_FindLocalOrGlobal");
		def32 = NULL;
	}
	
	*val = (eval_t *)&pr_progstate[pr_typecurrent].globals[def32->ofs];
	return &def;
}

char *COM_TrimString(char *str)
{
	int i;
	static char buffer[256];
	while (*str <= ' ' && *str>'\0')
		str++;

	for (i = 0; i < 255; i++)
	{
		if (*str <= ' ')
			break;
		buffer[i] = *str++;
	}
	buffer[i] = '\0';
	return buffer;
}

char *EvaluateDebugString(progfuncs_t *progfuncs, char *key)
{
	static char buf[256];
	char *c, *c2;
	ddef32_t *def;
	fdef_t *fdef;
	eval_t *val;
	char *assignment;
	int type;
	ddef32_t fakedef;
	eval_t fakeval;

	assignment = strchr(key, '=');
	if (assignment)
		*assignment = '\0';

	c = strchr(key, '.');
	if (c) *c = '\0';
	def = ED_FindLocalOrGlobal(progfuncs, key, &val);	
	if (!def)
	{
		if (atoi(key))
		{
			def = &fakedef;
			def->ofs = 0;
			def->type = ev_entity;
			val = &fakeval;
			val->edict = atoi(key);
		}
	}
	if (c) *c = '.';
	if (!def)
	{		
		return "(Bad string)";
	}	
	type = def->type;

	//go through ent vars
	c = strchr(key, '.');	
	while(c)
	{
		c2 = c+1;
		c = strchr(c2, '.');
		type = type &~DEF_SAVEGLOBAL;
		if (current_progstate->types)
			type = current_progstate->types[type].type;
		if (type != ev_entity)
			return "'.' without entity";
		if (c)*c = '\0';
		fdef = ED_FindField(progfuncs, COM_TrimString(c2));
		if (c)*c = '.';
		if (!fdef)
			return "(Bad string)";
		val = (eval_t *) (((char *)PROG_TO_EDICT(progfuncs, val->_int)->fields) + fdef->ofs*4);		
		type = fdef->type;
	}
	
	if (assignment)
	{
		assignment++;
		switch (type&~DEF_SAVEGLOBAL)
		{
		case ev_string:
			*(string_t *)val = PR_StringToProgs(progfuncs, ED_NewString (progfuncs, assignment, 0));
			break;
			
		case ev_float:
			*(float *)val = (float)atof (assignment);
			break;

		case ev_integer:
			*(int *)val = atoi (assignment);
			break;
			
/*		case ev_vector:
			strcpy (string, assignment);
			v = string;
			w = string;
			for (i=0 ; i<3 ; i++)
			{
				while (*v && *v != ' ')
					v++;
				*v = 0;
				((float *)d)[i] = (float)atof (w);
				w = v = v+1;
			}
			break;
*/
		case ev_entity:
			*(int *)val = EDICT_TO_PROG(progfuncs, EDICT_NUM(progfuncs, atoi (assignment)));
			break;

		case ev_field:
			fdef = ED_FindField (progfuncs, assignment);
			if (!fdef)
			{
				int l,nl = strlen(assignment);
				strcpy(buf, "Can't find field ");
				l = strlen(buf);
				if (nl > sizeof(buf)-l-2)
					nl = sizeof(buf)-l-2;
				memcpy(buf+l, assignment, nl);
				assignment[l+nl+0] = '\n';
				assignment[l+nl+1] = 0;
				return buf;
			}
			*(int *)val = G_INT(fdef->ofs);
			break;

		case ev_function:
			{
				dfunction_t *func;
				int i;
				int progsnum = -1;
				char *s = assignment;
				if (s[0] && s[1] == ':')
				{
					progsnum = atoi(s);
					s+=2;
				}
				else if (s[0] && s[1] && s[2] == ':')
				{
					progsnum = atoi(s);
					s+=3;
				}

				func = ED_FindFunction (progfuncs, s, &i, progsnum);
				if (!func)
				{
					int l,nl = strlen(s);

					assignment[-1] = '=';

					strcpy(buf, "Can't find field ");
					l = strlen(buf);
					if (nl > sizeof(buf)-l-2)
						nl = sizeof(buf)-l-2;
					memcpy(buf+l, assignment, nl);
					assignment[l+nl+0] = '\n';
					assignment[l+nl+1] = 0;
					return buf;
				}
				*(func_t *)val = (func - pr_progstate[i].functions) | (i<<24);
			}
			break;

		default:
			break;

		}
		assignment[-1] = '=';
	}
	strcpy(buf, PR_ValueString(progfuncs, type, val));

	return buf;
}

int debugstatement;
//int EditorHighlightLine(window_t *wnd, int line);
void SetExecutionToLine(progfuncs_t *progfuncs, int linenum)
{
	int pn = pr_typecurrent;
	int snum;
	dfunction_t *f = pr_xfunction;

	switch(current_progstate->intsize)
	{
	case 16:
		for (snum = f->first_statement; pr_progstate[pn].linenums[snum] < linenum; snum++) 
		{
			if (pr_statements16[snum].op == OP_DONE)
				return;
		}
		break;
	case 24:
	case 32:
		for (snum = f->first_statement; pr_progstate[pn].linenums[snum] < linenum; snum++) 
		{
			if (pr_statements32[snum].op == OP_DONE)
				return;
		}
		break;
	default:
		Sys_Error("Bad intsize");
		snum = 0;
	}
	debugstatement = snum;
//	EditorHighlightLine(editwnd, pr_progstate[pn].linenums[snum]);
}

//0 clear. 1 set, 2 toggle, 3 check
int PR_ToggleBreakpoint(progfuncs_t *progfuncs, char *filename, int linenum, int flag)	//write alternate route to work by function name.
{
	int ret=0;
	unsigned int fl;
	unsigned int i;
	int pn = pr_typecurrent;
	dfunction_t *f;
	int op;

	for (pn = 0; (unsigned)pn < maxprogs; pn++)
	{
		if (!pr_progstate || !pr_progstate[pn].progs)
			continue;

		if (linenum)	//linenum is set means to set the breakpoint on a file and line
		{
			if (!pr_progstate[pn].linenums)
				continue;

			for (f = pr_progstate[pn].functions, fl = 0; fl < pr_progstate[pn].progs->numfunctions; f++, fl++)
			{
				if (!stricmp(f->s_file+progfuncs->stringtable, filename))
				{
					for (i = f->first_statement; ; i++)
					{
						if (pr_progstate[pn].linenums[i] >= linenum)
						{
							fl = pr_progstate[pn].linenums[i];
							for (; ; i++)
							{
								if ((unsigned int)pr_progstate[pn].linenums[i] > fl)
									break;

								switch(pr_progstate[pn].intsize)
								{
								case 16:
									op = ((dstatement16_t*)pr_progstate[pn].statements + i)->op;
									break;
								case 24:
								case 32:
									op = ((dstatement32_t*)pr_progstate[pn].statements + i)->op;
									break;
								default:
									Sys_Error("Bad intsize");
									op = 0;
								}
								switch (flag)
								{
								default:
									if (op & 0x8000)
									{
										op &= ~0x8000;
										ret = false;
										flag = 0;
									}
									else
									{
										op |= 0x8000;
										ret = true;
										flag = 1;
									}
									break;
								case 0:
									op &= ~0x8000;
									ret = false;
									break;
								case 1:
									op |= 0x8000;
									ret = true;
									break;
								case 3:
									if (op & 0x8000)
										return true;
								}
								switch(pr_progstate[pn].intsize)
								{
								case 16:
									((dstatement16_t*)pr_progstate[pn].statements + i)->op = op;
									break;
								case 24:
								case 32:
									((dstatement32_t*)pr_progstate[pn].statements + i)->op = op;
									break;
								default:
									Sys_Error("Bad intsize");
									op = 0;
								}							
							}
							goto cont;
						}
					}
				}
			}
		}
		else	//set the breakpoint on the first statement of the function specified.
		{
			for (f = pr_progstate[pn].functions, fl = 0; fl < pr_progstate[pn].progs->numfunctions; f++, fl++)
			{
				if (!strcmp(f->s_name+progfuncs->stringtable, filename))
				{
					i = f->first_statement;
					switch(pr_progstate[pn].intsize)
					{
					case 16:
						op = ((dstatement16_t*)pr_progstate[pn].statements + i)->op;
						break;
					case 24:
					case 32:
						op = ((dstatement32_t*)pr_progstate[pn].statements + i)->op;
						break;
					default:
						Sys_Error("Bad intsize");
					}
					switch (flag)
					{
					default:
						if (op & 0x8000)
						{
							op &= ~0x8000;
							ret = false;
							flag = 0;
						}
						else
						{
							op |= 0x8000;
							ret = true;
							flag = 1;
						}
						break;
					case 0:
						op &= ~0x8000;
						ret = false;
						break;
					case 1:
						op |= 0x8000;
						ret = true;
						break;
					case 3:
						if (op & 0x8000)
							return true;
					}
					switch(pr_progstate[pn].intsize)
					{
					case 16:
						((dstatement16_t*)pr_progstate[pn].statements + i)->op = op;
						break;
					case 24:
					case 32:
						((dstatement32_t*)pr_progstate[pn].statements + i)->op = op;
						break;
					default:
						Sys_Error("Bad intsize");
					}
					break;
				}
			}
		}
cont:
		continue;
	}

	return ret;
}

int ShowStep(progfuncs_t *progfuncs, int statement)
{
//	return statement;
//	texture realcursortex;
static int lastline = 0;
static char *lastfile = 0;

	int pn = pr_typecurrent;
	int i;
	dfunction_t *f = pr_xfunction;	

	if (f && pr_progstate[pn].linenums && externs->useeditor)
	{
		if (lastline == pr_progstate[pn].linenums[statement] && lastfile == f->s_file+progfuncs->stringtable)
			return statement;	//no info/same line as last time

		lastline = pr_progstate[pn].linenums[statement];
		lastfile = f->s_file+progfuncs->stringtable;

		lastline = externs->useeditor(progfuncs, lastfile, lastline, 0, NULL);

		if (pr_progstate[pn].linenums[statement] != lastline)
		{
			for (i = f->first_statement; ; i++)
			{
				if (lastline == pr_progstate[pn].linenums[i])
				{
					return i;
				}
				else if (lastline <= pr_progstate[pn].linenums[i])
				{
					return statement;
				}
			}
		}
	}
	else if (f)	//annoying.
	{
		if (*(f->s_file+progfuncs->stringtable))	//if we can't get the filename, then it was stripped, and debugging it like this is useless
			if (externs->useeditor)
				externs->useeditor(progfuncs, f->s_file+progfuncs->stringtable, -1, 0, NULL);
		return statement;
	}
	

	return statement;
}

//DMW: all pointer functions are modified to be absoloute pointers from NULL not sv_edicts
/*
====================
PR_ExecuteProgram
====================
*/
void PR_ExecuteCode (progfuncs_t *progfuncs, int s)
{
	eval_t	*t, *swtch=NULL;

	int swtchtype;
	dstatement16_t	*st16;
	dstatement32_t	*st32;
	dfunction_t	*newf;
	int		runaway;
	int		i;
	int p;
	edictrun_t	*ed;
	eval_t	*ptr;

	float *glob;

	int fnum;

	prinst->continuestatement = -1;
#ifdef QCJIT
	if (prinst->usejit)
	{
		PR_EnterJIT(progfuncs, s);
		return;
	}
#endif
	fnum = pr_xfunction - pr_functions;

	runaway = 100000000;

#define PRBOUNDSCHECK
#define RUNAWAYCHECK()							\
	if (!--runaway)								\
	{											\
		pr_xstatement = st-pr_statements;		\
		PR_StackTrace(progfuncs);				\
		printf ("runaway loop error");			\
		while(pr_depth > prinst->exitdepth)		\
			PR_LeaveFunction(progfuncs);		\
		pr_spushed = 0;							\
		return;									\
	}

#define OPA ((eval_t *)&glob[st->a])
#define OPB ((eval_t *)&glob[st->b])
#define OPC ((eval_t *)&glob[st->c])

restart:	//jumped to when the progs might have changed.
	glob = pr_globals;
	switch (current_progstate->intsize)
	{
	case 16:
#define INTSIZE 16
		st16 = &pr_statements16[s];
		while (pr_trace)
		{
			#define DEBUGABLE
			#ifdef SEPARATEINCLUDES
				#include "execloop16d.h"
			#else
				#include "execloop.h"
			#endif
			#undef DEBUGABLE
		}
		
		while(1)
		{
			#include "execloop.h"
		}	
#undef INTSIZE
		Sys_Error("PR_ExecuteProgram - should be unreachable");
		break;
	case 24:
	case 32:
#define INTSIZE 32
		st32 = &pr_statements32[s];
		while (pr_trace)
		{
			#define DEBUGABLE
			#ifdef SEPARATEINCLUDES
				#include "execloop32d.h"
			#else
				#include "execloop.h"
			#endif
			#undef DEBUGABLE
		}
		
		while(1)
		{
			#ifdef SEPARATEINCLUDES
				#include "execloop32.h"
			#else
				#include "execloop.h"
			#endif
		}
#undef INTSIZE	
		Sys_Error("PR_ExecuteProgram - should be unreachable");
		break;
	default:
		Sys_Error("PR_ExecuteProgram - bad intsize");
	}
}


void PR_ExecuteProgram (progfuncs_t *progfuncs, func_t fnum)
{
	dfunction_t	*f;
	int		i;
	unsigned int initial_progs;
	int		oldexitdepth;

	int s;

	int tempdepth;

	unsigned int newprogs = (fnum & 0xff000000)>>24;

	initial_progs = pr_typecurrent;
	if (newprogs != initial_progs)
	{
		if (newprogs >= maxprogs || !&pr_progstate[newprogs].globals)	//can happen with hexen2...
		{
			printf("PR_ExecuteProgram: tried branching into invalid progs\n");
			return;
		}
		PR_MoveParms(progfuncs, newprogs, pr_typecurrent);
		PR_SwitchProgs(progfuncs, newprogs);
	}

	if (!(fnum & ~0xff000000) || (signed)(fnum & ~0xff000000) >= pr_progs->numfunctions)
	{
//		if (pr_global_struct->self)
//			ED_Print (PROG_TO_EDICT(pr_global_struct->self));
		printf("PR_ExecuteProgram: NULL function from exe\n");
//		Host_Error ("PR_ExecuteProgram: NULL function from exe");

//		PR_MoveParms(0, pr_typecurrent);
		PR_SwitchProgs(progfuncs, initial_progs);
		return;
	}

	oldexitdepth = prinst->exitdepth;

	f = &pr_functions[fnum & ~0xff000000];

	if (f->first_statement < 0)
	{	// negative statements are built in functions
		i = -f->first_statement;

		if (i < externs->numglobalbuiltins)
			(*externs->globalbuiltins[i]) (progfuncs, (struct globalvars_s *)current_progstate->globals);
		else
		{
			i -= externs->numglobalbuiltins;
			if (i > current_progstate->numbuiltins)
			{
				printf ("Bad builtin call number %i (from exe)\n", -f->first_statement);
			//	PR_MoveParms(p, pr_typecurrent);
				PR_SwitchProgs(progfuncs, initial_progs);
				return;
			}
			current_progstate->builtins [i] (progfuncs, (struct globalvars_s *)current_progstate->globals);
		}
		PR_MoveParms(progfuncs, initial_progs, pr_typecurrent);
		PR_SwitchProgs(progfuncs, initial_progs);
		return;
	}

	if (pr_trace)
		pr_trace--;

// make a stack frame
	prinst->exitdepth = pr_depth;


	s = PR_EnterFunction (progfuncs, f, initial_progs);

	tempdepth = prinst->numtempstringsstack;
	PR_ExecuteCode(progfuncs, s);


	PR_MoveParms(progfuncs, initial_progs, pr_typecurrent);
	PR_SwitchProgs(progfuncs, initial_progs);

	PR_FreeTemps(progfuncs, tempdepth);
	prinst->numtempstringsstack = tempdepth;

	prinst->exitdepth = oldexitdepth;
}






typedef struct {
	int fnum;
	int progsnum;
	int statement;
} qcthreadstack_t;
typedef struct qcthread_s {
	int fstackdepth;
	qcthreadstack_t fstack[MAX_STACK_DEPTH];
	int lstackused;
	int lstack[LOCALSTACK_SIZE];
	int xstatement;
	int xfunction;
	progsnum_t xprogs;
} qcthread_t;

struct qcthread_s *PR_ForkStack(progfuncs_t *progfuncs)
{	//QC code can call builtins that call qc code.
	//to get around the problems of restoring the builtins we simply don't save the thread over the builtin.
	int i, l;
	int ed = prinst->exitdepth;
	int localsoffset, baselocalsoffset;
	qcthread_t *thread = memalloc(sizeof(qcthread_t));
	dfunction_t *f;
	
	//copy out the functions stack.
	for (i = 0,localsoffset=0; i < ed; i++)
	{
		if (i+1 == pr_depth)
			f = pr_xfunction;
		else
			f = pr_stack[i+1].f;
		localsoffset += f->locals;	//this is where it crashes
	}
	baselocalsoffset = localsoffset;
	for (i = ed; i < pr_depth; i++)
	{
		thread->fstack[i-ed].fnum = pr_stack[i].f - pr_progstate[pr_stack[i].progsnum].functions; 
		thread->fstack[i-ed].progsnum = pr_stack[i].progsnum;
		thread->fstack[i-ed].statement = pr_stack[i].s;

		if (i+1 == pr_depth)
			f = pr_xfunction;
		else
			f = pr_stack[i+1].f;
		localsoffset += f->locals;
	}
	thread->fstackdepth = pr_depth - ed;

	for (i = pr_depth - 1; i >= ed ; i--)
	{
		if (i+1 == pr_depth)
			f = pr_xfunction;
		else
			f = pr_stack[i+1].f;
		localsoffset -= f->locals;
		for (l = 0; l < f->locals; l++)
		{
			thread->lstack[localsoffset-baselocalsoffset + l ] = ((int *)pr_globals)[f->parm_start + l];
			((int *)pr_globals)[f->parm_start + l] = localstack[localsoffset+l];	//copy the old value into the globals (so the older functions have the correct locals.
		}
	}

	for (i = ed; i < pr_depth ; i++)	//we need to get the locals back to how they were.
	{
		if (i+1 == pr_depth)
			f = pr_xfunction;
		else
			f = pr_stack[i+1].f;

		for (l = 0; l < f->locals; l++)
		{
			((int *)pr_globals)[f->parm_start + l] = thread->lstack[localsoffset-baselocalsoffset + l];
		}
		localsoffset += f->locals;
	}
	thread->lstackused = localsoffset - baselocalsoffset;

	thread->xstatement = pr_xstatement;
	thread->xfunction = pr_xfunction - pr_progstate[pr_typecurrent].functions;
	thread->xprogs = pr_typecurrent;

	return thread;
}

void PR_ResumeThread (progfuncs_t *progfuncs, struct qcthread_s *thread)
{
	dfunction_t	*f, *oldf;
	int		i,l,ls;
	progsnum_t initial_progs;
	int		oldexitdepth;

	int s;
	int tempdepth;

	progsnum_t prnum = thread->xprogs;
	int fnum = thread->xfunction;

	if (localstack_used + thread->lstackused > LOCALSTACK_SIZE)
		PR_RunError(progfuncs, "Too many locals on resumtion of QC thread\n");

	if (pr_depth + thread->fstackdepth > MAX_STACK_DEPTH)
		PR_RunError(progfuncs, "Too large stack on resumtion of QC thread\n");


	//do progs switching stuff as appropriate. (fteqw only)
	initial_progs = pr_typecurrent;
	PR_MoveParms(progfuncs, prnum, pr_typecurrent);
	PR_SwitchProgs(progfuncs, prnum);


	oldexitdepth = prinst->exitdepth;
	prinst->exitdepth = pr_depth;

	ls = 0;
	//add on the callstack.
	for (i = 0; i < thread->fstackdepth; i++)
	{
		if (pr_depth == prinst->exitdepth)
		{
			pr_stack[pr_depth].f = pr_xfunction;
			pr_stack[pr_depth].s = pr_xstatement;
			pr_stack[pr_depth].progsnum = initial_progs;
		}
		else
		{
			pr_stack[pr_depth].progsnum = thread->fstack[i].progsnum;
			pr_stack[pr_depth].f = pr_progstate[thread->fstack[i].progsnum].functions + thread->fstack[i].fnum; 
			pr_stack[pr_depth].s = thread->fstack[i].statement;
		}

		if (i+1 == thread->fstackdepth)
			f = &pr_functions[fnum];
		else
			f = pr_progstate[thread->fstack[i+1].progsnum].functions + thread->fstack[i+1].fnum;
		for (l = 0; l < f->locals; l++)
		{
			localstack[localstack_used++] = ((int *)pr_globals)[f->parm_start + l];
			((int *)pr_globals)[f->parm_start + l] = thread->lstack[ls++];
		}

		pr_depth++;
	}

	if (ls != thread->lstackused)
		PR_RunError(progfuncs, "Thread stores incorrect locals count\n");

	
	f = &pr_functions[fnum];

//	thread->lstackused -= f->locals;	//the current function is the odd one out.

	//add on the locals stack
	memcpy(localstack+localstack_used, thread->lstack, sizeof(int)*thread->lstackused);
	localstack_used += thread->lstackused;

	//bung the locals of the current function on the stack.
//	for (i=0 ; i < f->locals ; i++)
//		((int *)pr_globals)[f->parm_start + i] = 0xff00ff00;//thread->lstack[thread->lstackused+i];


//	PR_EnterFunction (progfuncs, f, initial_progs);
	oldf = pr_xfunction;
	pr_xfunction = f;
	s = thread->xstatement;

	tempdepth = prinst->numtempstringsstack;
	PR_ExecuteCode(progfuncs, s);


	PR_MoveParms(progfuncs, initial_progs, pr_typecurrent);
	PR_SwitchProgs(progfuncs, initial_progs);
	PR_FreeTemps(progfuncs, tempdepth);
	prinst->numtempstringsstack = tempdepth;

	prinst->exitdepth = oldexitdepth;
	pr_xfunction = oldf;
}

void	PR_AbortStack			(progfuncs_t *progfuncs)
{
	while(pr_depth > prinst->exitdepth+1)
		PR_LeaveFunction(progfuncs);
	prinst->continuestatement = 0;
}

