fteqw/engine/qclib/decomp.c

#include "qcc.h"
//#include "decomp.h"

//FIXME: there's still a load of mallocs, so we don't allow this more than once per process.
//convert vector terms into floats when its revealed that they're using vector ops and not floats

#if defined(_WIN32) || defined(__DJGPP__)
#include <malloc.h>
#else
#include <alloca.h>
#endif

#undef printf
#define printf GUIprintf

#define OPF_FORSTART OP_NUMOPS
#define OP_MARK_END_DO 40000
#define OP_MARK_END_ELSE 1000

#define MAX_REGS 65536
#define dstatement_t QCC_dstatement32_t
#define statements destatements
#define functions defunctions
#define strings destrings
static dstatement_t *statements;
static float *pr_globals;
static char		*strings;
static QCC_ddef32_t *globals;
static dfunction_t *functions;

static int ofs_return;
static int ofs_parms[MAX_PARMS];
static int ofs_size = 3;

static QCC_ddef_t		*globalofsdef[MAX_REGS];


//forward declarations.
QCC_ddef_t *GetField(const char *name);

#include <stdio.h>

/*int QC_snprintfz(char *buffer, size_t maxlen, const char *format, ...)
{
	int p;
	va_list		argptr;

	if (!maxlen)
		return -1;
		
	va_start (argptr, format);
	p = _vsnprintf (buffer, maxlen, format,argptr);
	va_end (argptr);
	buffer[maxlen-1] = 0;

	return p;
}*/

extern QCC_opcode_t pr_opcodes [];

int endofsystemfields;
int debug_offs = 0;
int assumeglobals = 0;	//unknown globals are assumed to be actual globals and NOT unlocked temps
int assumelocals = 0;	//unknown locals are assumed to be actual locals and NOT locked temps

vfile_t *Decompileofile;
vfile_t *Decompileprogssrc;
vfile_t *Decompileprofile;
char **DecompileProfiles;//[MAX_FUNCTIONS];
static char **rettypes;//[MAX_FUNCTIONS];

extern int quakeforgeremap[];

char *type_names[] =
{
	"void",
	"string",
	"float",
	"vector",
	"entity",
	"ev_field",
	"void()",
	"ev_pointer",
	"int",
	"__variant",
	"ev_struct",
	"ev_union",
	"ev_accessor",
	"ev_quat",
	"ev_uinteger"
};
char *typetoname(QCC_type_t *type)
{
	return type->name;
}

char *temp_type (int temp, dstatement_t *start, dfunction_t *df)
{
	int i;
	dstatement_t *stat;
	stat = start - 1;
	// determine the type of a temp

	while(stat > statements)
	{
		if (temp == stat->a)
			return typetoname(*pr_opcodes[stat->op].type_a);
		else if (temp == stat->b)
			return typetoname(*pr_opcodes[stat->op].type_b);
		else if (temp == stat->c)
			return typetoname(*pr_opcodes[stat->op].type_c);
		stat--;
	}

	// method 2
	// find a call to this function
	for (i = 0; i < numstatements; i++)
	{
		stat = &statements[i];

		if (stat->op >= OP_CALL0 && stat->op <= OP_CALL8 && ((eval_t *)&pr_globals[stat->a])->function == df - functions)
		{
			for(i++; i < numstatements; i++)
			{
				stat = &statements[i];
				if (ofs_return == stat->a && (*pr_opcodes[stat->op].type_a)->type != ev_void)
					return type_names[(*pr_opcodes[stat->op].type_a)->type];
				else if (ofs_return == stat->b && (*pr_opcodes[stat->op].type_b)->type != ev_void)
					return type_names[(*pr_opcodes[stat->op].type_b)->type];
				else if (stat->op == OP_DONE)
					break;
				else if (stat->op >= OP_CALL0 && stat->op <= OP_CALL8 && stat->a != df - functions)
					break;
			}
		}
	}

	printf("warning: Could not determine return type for %s\n", df->s_name + strings);

	return "float";

}

boolean IsConstant(QCC_ddef_t *def)
{

	int i;
	dstatement_t *d;

	if (def->type & DEF_SAVEGLOBAL)
		return false;

	if (pr_globals[def->ofs] == 0)
		return false;

	for (i = 1; i < numstatements; i++)
	{
		d = &statements[i];
		if (d->b == def->ofs)
		{
			if (pr_opcodes[d->op].associative == ASSOC_RIGHT)
			{
				if (d->op - OP_STORE_F < 6)
				{
					return false;
				}
			}
		}
	}
	return true;
}

char *type_name (QCC_ddef_t *def)
{
	QCC_ddef_t *j;

	switch(def->type&~DEF_SAVEGLOBAL)
	{
	case ev_field:
	case ev_pointer:
		j = GetField(def->s_name + strings);
		if (j)
			return qcva(".%s",type_names[j->type]);
		else
			return type_names[def->type&~DEF_SAVEGLOBAL];
	case ev_void:
	case ev_string:
	case ev_entity:
	case ev_vector:
	case ev_float:
		return type_names[def->type&~DEF_SAVEGLOBAL];
	case ev_function:
		return "void()";
	case ev_integer:
		return "int";
//	case ev_uinteger:
//		return "unsigned";
//	case ev_quat:
//		return "quat";
	default:
		return "float";
	}
};

extern int numstatements;

extern int numfunctions;

#define FILELISTSIZE 62



/*
===============
PR_String

Returns a string suitable for printing (no newlines, max 60 chars length)
===============
*/
const char *PR_String (const char *string)
{
	static char buf[80];
	char	*s;
	
	s = buf;
	*s++ = '"';
	while (string && *string)
	{
		if (s == buf + sizeof(buf) - 2)
			break;
		if (*string == '\n')
		{
			*s++ = '\\';
			*s++ = 'n';
		}
		else if (*string == '"')
		{
			*s++ = '\\';
			*s++ = '"';
		}
		else
			*s++ = *string;
		string++;
		if (s - buf > 60)
		{
			*s++ = '.';
			*s++ = '.';
			*s++ = '.';
			break;
		}
	}
	*s++ = '"';
	*s++ = 0;
	return buf;
}
/*
============
PR_ValueString

Returns a string describing *data in a type specific manner
=============
*/


static char *PR_ValueString (etype_t type, void *val)
{
	static char	line[8192];

	dfunction_t	*f;
	
	switch (type)
	{
	case ev_string:
		QC_snprintfz(line, sizeof(line), "%s", PR_String(strings + *(int *)val));
		break;
	case ev_entity:	
		QC_snprintfz(line, sizeof(line), "entity %i", *(int *)val);
		break;
	case ev_function:
		f = functions + *(int *)val;
		if (!f)
			QC_snprintfz(line, sizeof(line), "undefined function");
		else
			QC_snprintfz(line, sizeof(line), "%s()", strings + f->s_name);
		break;
	/*
	case ev_field:
		def = PR_DefForFieldOfs ( *(int *)val );
		sprintf (line, ".%s", def->name);
		break;
	*/
	case ev_void:
		QC_snprintfz(line, sizeof(line), "void");
		break;
	case ev_float:
		{
			unsigned int high = *(unsigned int*)val & 0xff000000;
			if (high == 0xff000000 || !high)
				//FIXME this is probably a string or something, but we don't really know what type it is.
				QC_snprintfz(line, sizeof(line), "(float)(__variant)%ii", *(int*)val);
			else
				QC_snprintfz(line, sizeof(line), "%5.1f", *(float *)val);
		}
		break;
	case ev_vector:
		QC_snprintfz(line, sizeof(line), "'%5.1f %5.1f %5.1f'", ((float *)val)[0], ((float *)val)[1], ((float *)val)[2]);
		break;
	case ev_pointer:
		QC_snprintfz(line, sizeof(line), "pointer");
		break;
	case ev_field:
		QC_snprintfz(line, sizeof(line), "<FIELD@%i>", *(int*)val);
		break;
	default:
		QC_snprintfz(line, sizeof(line), "bad type %i", type);
		break;
	}
	
	return line;
}


static char *filenames[] =
{
	"makevectors",		"defs.qc",
	"button_wait",		"buttons.qc",
	"anglemod",		"ai.qc",
	"boss_face",		"boss.qc",
	"info_intermission",	"client.qc",
	"CanDamage",	"combat.qc",
	"demon1_stand1",	"demon.qc",
	"dog_bite",		"dog.qc",
	"door_blocked",		"doors.qc",
	"Laser_Touch",		"enforcer.qc",
	"knight_attack",			"fight.qc",
	"f_stand1",	"fish.qc",
	"hknight_shot",	"hknight.qc",
	"SUB_regen",		"items.qc",
	"knight_stand1",	"knight.qc",
	"info_null",		"misc.qc",
	"monster_use",		"monsters.qc",
	"OgreGrenadeExplode",	"ogre.qc",
	"old_idle1",			"oldone.qc",
	"plat_spawn_inside_trigger", "plats.qc",
	"player_stand1",		"player.qc",
	"shal_stand",	"shalrath.qc",
	"sham_stand1",		"shambler.qc",
	"army_stand1",		"soldier.qc",
	"SUB_Null",			"subs.qc",
	"tbaby_stand1",		"tarbaby.qc",
	"trigger_reactivate",	"triggers.qc",
	"W_Precache",			"weapons.qc",
	"LaunchMissile",	"wizard.qc",
	"main",		"world.qc",
	"zombie_stand1",	"zombie.qc"
};

//FIXME: parse fteextensions.qc instead, or something.
#define QW(x) //x,
static struct {
	int num;
	char *name;	//purly for readability.
	QCC_type_t **returns;
	QCC_type_t **params[8];
	char *text;
} builtins[]=
{
	{0,		NULL,				NULL, {NULL},																NULL},								
	{1,		"makevectors",		NULL, {&type_vector},														"void (vector ang)"},
	{2,		"setorigin",		NULL, {&type_entity, &type_vector},											"void (entity e, vector o)"},
	{3,		"setmodel",			NULL, {&type_entity, &type_string},											"void (entity e, string m)"},
	{4,		"setsize",			NULL, {&type_entity, &type_vector, &type_vector},							"void (entity e, vector min, vector max)"},
	{5,		NULL,				NULL, {NULL},																NULL},
	{6,		NULL,				NULL, {NULL},																"void ()"},
	{7,		"random",			NULL, {NULL},																"float ()"},
	{8,		"sound",			NULL, {&type_entity, &type_float, &type_string, &type_float, &type_float},	"void (entity e, float chan, string samp, float vol, float atten)"},
	{9,		"normalize",		&type_vector, {&type_vector},												"vector (vector v)"},
	{10,	"error",			NULL, {&type_string},														"void (string e)"},
	{11,	"objerror",			NULL, {&type_string},														"void (string e)"},
	{12,	"vlen",				&type_float, {&type_vector},												"float (vector v)"},
	{13,	"vectoyaw",			&type_float, {&type_vector},												"float (vector v)"},
	{14,	"spawn",			&type_entity, {NULL},														"entity ()"},
	{15,	"remove",			NULL, {&type_entity},														"void (entity e)"},
	{16,	"traceline",		NULL, {&type_vector, &type_vector, &type_float, &type_entity},				"void (vector v1, vector v2, float nomonsters, entity forent)"},
	{17,	NULL,				NULL, {NULL},																"entity ()"},
	{18,	"find",				&type_entity, {&type_entity, &type_field, &type_string},					"entity (entity start, .string fld, string match)"},
	{19,	"precache_sound",	NULL, {&type_string},														"string (string s)"},
	{20,	"precache_model",	NULL, {&type_string},														"string (string s)"},
	{21,	"stuffcmd",			NULL, {&type_entity, &type_string},											"void (entity client, string s)"},
	{22,	"findradius",		NULL, {&type_vector, &type_float},											"entity (vector org, float rad)"},
	{23,	"bprint",			NULL, {QW(&type_float) &type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string}, "void (...)"},
	{24,	"sprint",			NULL, {&type_entity, QW(&type_float) &type_string,&type_string,&type_string,&type_string,&type_string,&type_string}, "void (...)"},
	{25,	"dprint",			NULL, {&type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string}, "void (...)"},
	{26,	"ftos",				&type_string, {&type_float},												"string (float f)"},
	{27,	"vtos",				&type_string, {&type_vector},												"string (vector v)"},
	{28,	"coredump",			NULL, {NULL},																"void ()"},
	{29,	"traceon",			NULL, {NULL},																"void ()"},
	{30,	"traceoff",			NULL, {NULL},																"void ()"},
	{31,	"eprint",			NULL, {&type_entity},														"void (entity e)"},
	{32,	"walkmove",			&type_float, {&type_float, &type_float},									"float (float yaw, float dist)"},
	{33,	NULL,				NULL, {NULL},																NULL},
	{34,	"droptofloor",		NULL, {&type_float, &type_float},											"float ()"},
	{35,	"lightstyle",		NULL, {&type_float, &type_string},											"void (float style, string value)"},
	{36,	"rint",				&type_float, {&type_vector},												"float (float v)"},
	{37,	"floor",			&type_float, {&type_vector},												"float (float v)"},
	{38,	"ceil",				&type_float, {&type_vector},												"float (float v)"},
	{39,	NULL,				NULL, {NULL},																NULL},
	{40,	"checkbottom",		&type_float, {&type_entity},												"float (entity e)"},
	{41,	"pointcontents",	&type_float, {&type_vector},												"float (vector v)"},
	{42,	NULL,				NULL, {NULL},																NULL},
	{43,	"fabs",				&type_float, {&type_float},													"float (float f)"},
	{44,	"aim",				NULL, {&type_entity, &type_float},											"vector (entity e, float speed)"},
	{45,	"cvar",				&type_string, {&type_string},												"float (string s)"},
	{46,	"localcmd",			NULL, {&type_string},														"void (string s)"},
	{47,	"nextent",			&type_entity, {&type_entity},												"entity (entity e)"},
	{48,	"",					NULL, {&type_vector, &type_vector, &type_float, &type_float},				"void (vector o, vector d, float color, float count)"},
	{49,	"changeyaw",		NULL, {NULL},																"void ()"},
	{50,	NULL,				NULL, {NULL},																NULL},
	{51,	"vectoangles",		&type_vector, {&type_vector},												"vector (vector v)"},
	{52,	"WriteByte",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{53,	"WriteChar",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{54,	"WriteShort",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{55,	"WriteLong",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{56,	"WriteCoord",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{57,	"WriteAngle",		NULL, {&type_float, &type_float},											"void (float to, float f)"},
	{58,	"WriteString",		NULL, {&type_float, &type_string},											"void (float to, string s)"},
	{59,	"WriteEntity",		NULL, {&type_float, &type_entity},											"void (float to, entity s)"},
	{60,	NULL,				NULL, {NULL},																NULL},
	{61,	NULL,				NULL, {NULL},																NULL},
	{62,	NULL,				NULL, {NULL},																NULL},
	{63,	NULL,				NULL, {NULL},																NULL},
	{64,	NULL,				NULL, {NULL},																NULL},
	{65,	NULL,				NULL, {NULL},																NULL},
	{66,	NULL,				NULL, {NULL},																NULL},
	{67,	"movetogoal",		NULL, {&type_float},														"void (float step)"},
	{68,	"precache_file",	NULL, {&type_string},														"string (string s)"},
	{69,	"makestatic",		NULL, {&type_entity},														"void (entity e)"},
	{70,	"changelevel",		NULL, {&type_string},														"void (string s)"},
	{71,	NULL,				NULL, {NULL},																NULL},
	{72,	"cvar_set",			NULL, {&type_string, &type_string},											"void (string var, string val)"},
	{73,	"centerprint",		NULL, {&type_entity,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string},	"void (entity client, string s, ...)"},
	{74,	"ambientsound",		NULL, {&type_vector, &type_string, &type_float, &type_float},				"void (vector pos, string samp, float vol, float atten)"},
	{75,	"precache_model2",	NULL, {&type_string},														"string (string s)"},
	{76,	"precache_sound2",	NULL, {&type_string},														"string (string s)"},
	{77,	"precache_file2",	NULL, {&type_string},														"string (string s)"},
	{78,	"setspawnparms",	NULL, {&type_entity},														"void (entity e)"},

//quakeworld specific
	{79,	"logfrag",			NULL, {&type_entity, &type_entity},											"void(entity killer, entity killee)"},
	{80,	"infokey",			&type_string, {&type_entity, &type_string},									"string(entity e, string key)"},
	{81,	"stof",				&type_float, {&type_string},												"float(string s)"},
	{82,	"multicast",		NULL, {&type_vector, &type_float},											"void(vector where, float set)"},

//these are mvdsv specific
	{83,	"executecmd",		NULL, {NULL},																NULL},
	{84,	"tokenize",			NULL, {&type_string},														NULL},
	{85,	"argc",				&type_float, {NULL},														"float()"},
	{86,	"argv",				&type_string, {&type_float},												"string(float f)"},
	{87,	"teamfield",		NULL, {NULL},																"void(.string fs)"},
	{88,	"substr",			&type_string, {&type_string, &type_float, &type_float},						"string(string, float, float)"},
	{89,	"strcat",			&type_string, {&type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string,&type_string},					"string (...)"},
	{90,	"strlen",			&type_float, {&type_string},												"float(string s)"},
	{91,	"str2byte",			&type_float, {&type_string},												"float(string s)"},
	{92,	NULL,				NULL, {NULL},																NULL},
	{93,	"newstr",			&type_string, {&type_string},												"string(...)"},
	{94,	"freestr",			NULL, {&type_string},														"void(string s)"},
	{95,	"conprint",			NULL, {NULL},																NULL},
	{96,	"readcmd",			&type_string, {&type_string},												"string(string cmd)"},
	{97,	"strcpy",			NULL, {NULL},																NULL},
	{98,	"strstr",			&type_string, {&type_string, &type_string},									"string(string str, string sub)"},
	{99,	"strncpy",			NULL, {NULL},																NULL},
	{100,	"log",				NULL, {NULL},																NULL},
	{101,	"redirectcmd",		NULL, {NULL},																NULL},
	{102,	"calltimeofday",	NULL, {NULL},																NULL},
	{103,	"forcedemoframe",	NULL, {NULL},																NULL},
};

char *DecompileValueString(etype_t type, void *val);
QCC_ddef_t *DecompileGetParameter(gofs_t ofs);
QCC_ddef_t *DecompileFindGlobal(const char *name);
char *DecompilePrintParameter(QCC_ddef_t * def);
QCC_ddef_t *DecompileFunctionGlobal(int funcnum);

char *ReadProgsCopyright(char *buf, size_t bufsize)
{
	char *copyright, *e;
	dprograms_t *progs = (dprograms_t*)buf;
	int lowest = progs->ofs_statements;
	lowest = min(lowest, progs->ofs_globaldefs);
	lowest = min(lowest, progs->ofs_fielddefs);
	lowest = min(lowest, progs->ofs_functions);
	lowest = min(lowest, progs->ofs_strings);
	lowest = min(lowest, progs->ofs_globals);
	lowest = min(lowest, progs->ofs_fielddefs);

	copyright = (char*)(progs+1);
	if (!strncmp("\r\n\r\n", copyright, 4))
	{
		copyright += 4;
		e = copyright+strlen(copyright)+1;
		if (e && !strncmp(e, "\r\n\r\n", 4))
		{
			if (e+4 <= buf+lowest)
			{
				return copyright;
			}

		}
	}
	return NULL;
}

int DecompileReadData(char *srcfilename, char *buf, size_t bufsize)
{
	dprograms_t progs;
	int i, j;
	void *p;
	char name[1024];
	QCC_ddef_t *fd;

	int stsz = 16, defsz=16;
//	int quakeforge = false;
	
	memcpy(&progs, buf, sizeof(progs));

	if (progs.version == PROG_VERSION)
		stsz = defsz = 16;
	else if (progs.version == 7)
	{
		if (progs.secondaryversion == PROG_SECONDARYVERSION16)
		{
			//regular 16bit progs, just an extended instruction set probably.		
			stsz = defsz = 16;
		}
		else if (progs.secondaryversion == PROG_SECONDARYVERSION32)
		{
			//32bit fte progs. everything is 32bit.
			stsz = defsz = 32;
		}
		else
		{
			//progs is kk7 (certain QW TF mods). defs are 16bit but statements are 32bit. so this is unusable for saved games.
			stsz = 32;
			defsz = 16;	//gah! fucked!
		}
	}
	else
	{
		stsz = defsz = 16;
//		quakeforge = true;
	}

	strings = buf + progs.ofs_strings;
	strofs = progs.numstrings;

	numstatements = progs.numstatements;

//	if (numstatements > MAX_STATEMENTS)
//		Sys_Error("Too many statements");
	if (stsz == 16)
	{
		const dstatement16_t	*statements6 = (const dstatement16_t*)(buf+progs.ofs_statements);
		statements = malloc(numstatements * sizeof(*statements));
		for (i = 0; i < numstatements; i++)
		{
			statements[i].op = statements6[i].op;

			if (statements[i].op == OP_GOTO)
				statements[i].a = (signed short)statements6[i].a;
			else
				statements[i].a = (unsigned short)statements6[i].a;

			if (statements[i].op == OP_IF_I || statements[i].op == OP_IFNOT_I || statements[i].op == OP_IF_F || statements[i].op == OP_IFNOT_F || statements[i].op == OP_IF_S || statements[i].op == OP_IFNOT_S)
				statements[i].b = (signed short)statements6[i].b;
			else
				statements[i].b = (unsigned short)statements6[i].b;

			statements[i].c = (unsigned short)statements6[i].c;
		}
	}
	else if (stsz == 32)
		statements = (dstatement32_t*)(buf+progs.ofs_statements);
	else
		Sys_Error("Unrecognised progs version");

	numfunctions = progs.numfunctions;
	functions = (dfunction_t*)(buf+progs.ofs_functions);
	DecompileProfiles = calloc(numfunctions, sizeof(*DecompileProfiles));
	rettypes = calloc(numfunctions, sizeof(*rettypes));

	numglobaldefs = progs.numglobaldefs;
	numfielddefs = progs.numfielddefs;
	if (defsz == 16)
	{
		const QCC_ddef16_t	*gd16 = (const QCC_ddef16_t*)(buf+progs.ofs_globaldefs);
		globals = malloc(numglobaldefs * sizeof(*globals));
		for (i = 0; i < numglobaldefs; i++)
		{
			globals[i].ofs = gd16[i].ofs;
			globals[i].s_name = gd16[i].s_name;
			globals[i].type = gd16[i].type;
		}


		gd16 = (const QCC_ddef16_t*)(buf+progs.ofs_fielddefs);
		fields = malloc(numfielddefs * sizeof(*fields));
		for (i = 0; i < numfielddefs; i++)
		{
			fields[i].ofs = gd16[i].ofs;
			fields[i].s_name = gd16[i].s_name;
			fields[i].type = gd16[i].type;
		}
	}
	else
	{
		globals = (QCC_ddef32_t*)(buf+progs.ofs_globaldefs);
		fields = (QCC_ddef32_t*)(buf+progs.ofs_fielddefs);
	}

	pr_globals = (float*)(buf+progs.ofs_globals);
	numpr_globals = progs.numglobals;

	printf("Decompiling...\n");
	printf("Read Data from %s:\n", srcfilename);
	printf("Total Size is %6i\n", bufsize);
	printf("Version Code is %i\n", progs.version);
	printf("CRC is %i\n", progs.crc);
	printf("%6i strofs\n", strofs);
	printf("%6i numstatements\n", numstatements);
	printf("%6i numfunctions\n", numfunctions);
	printf("%6i numglobaldefs\n", numglobaldefs);
	printf("%6i numfielddefs\n", numfielddefs);
	printf("%6i numpr_globals\n", numpr_globals);
	printf("----------------------\n");

	if (numpr_globals > MAX_REGS)
	{
		printf("fatal error: progs exceeds a limit\n");
		exit(1);
	}

	ofs_return = OFS_RETURN;
	for (i = 0; i < 8; i++)
		ofs_parms[i] = OFS_PARM0 + i * 3;
	ofs_size = 3;

/*
	if (quakeforge)
	{
		int typeremap[] = {ev_void, ev_string, ev_float, ev_vector, ev_entity, ev_field, ev_function, ev_pointer, ev_quat, ev_integer, ev_uinteger};
		for (i = 1; i < numglobaldefs; i++)
		{
			globals[i].type = (globals[i].type & DEF_SAVEGLOBGAL) | typeremap[globals[i].type&~DEF_SAVEGLOBGAL];
		}
		for (i = 1; i < numfielddefs; i++)
		{
			fields[i].type = (fields[i].type & DEF_SAVEGLOBGAL) | typeremap[fields[i].type&~DEF_SAVEGLOBGAL];
		}

		for (i = 1; i < numstatements; i++)
		{
			if (statements[i].op >= OP_H2_FIRST)// && statements[i].op <= OP_H2_FIRST+sizeof(quakeforgeremap)/sizeof(quakeforgeremap[0]))
				statements[i].op = quakeforgeremap[statements[i].op-OP_H2_FIRST];
		}

		fd = DecompileFindGlobal(".zero");
		if (fd)
			fd->ofs = -1;

		fd = DecompileFindGlobal(".return");
		if (fd)
		{
			ofs_return = fd->ofs;
			fd->ofs = -1;
		}

		for (i = 0; i < 8; i++)
		{
			QC_snprintfz(name, sizeof(name), ".param_%i", i);
			fd = DecompileFindGlobal(name);
			if (fd)
			{
				ofs_parms[i] = fd->ofs;
				fd->ofs = -1;
			}
		}

		fd = DecompileFindGlobal(".param_size");
		if (fd)
			ofs_size = ((int*)pr_globals)[fd->ofs];
	}
*/

	//fix up the globaldefs
	for (i = 1; i < numglobaldefs; i++)
	{
		if (globals[i].ofs < RESERVED_OFS)
			globals[i].ofs += numpr_globals;
	}
// fix up the functions
	for (i = 1; i < numfunctions; i++)
	{
		if ((unsigned)functions[i].s_name >= (unsigned)strofs || strlen(functions[i].s_name + strings) <= 0)
		{
			fd = DecompileFunctionGlobal(i);
			if (fd)
			{
				functions[i].s_name = fd->s_name;
				continue;
			}
			QC_snprintfz(name, sizeof(name), "function%i", i);
			name[strlen(name)] = 0;
			p = malloc(strlen(name + 1));
			strcpy(p, name);
			functions[i].s_name = (char *)p - strings;
		}
		if (functions[i].first_statement > 0 && !functions[i].locals && functions[i].numparms)
		{	//vanilla qcc apparently had a bug
			for (j = 0; j < functions[i].numparms; j++)
				functions[i].locals += functions[i].parm_size[j];
		}
	}

	return progs.version;
}

int 
DecompileGetFunctionIdxByName(const char *name)
{

	int i;

	for (i = 1; i < numfunctions; i++)
		if (!strcmp(name, strings + functions[i].s_name)) 
		{
			return i;
		}
	return 0;
}

const etype_t DecompileGetFieldTypeByDef(QCC_ddef_t *def)
{
	int i;
	int ofs = ((int*)pr_globals)[def->ofs];

	for (i = 1; i < numfielddefs; i++)
		if (fields[i].ofs == ofs) 
		{
			if (!strcmp(strings+def->s_name, strings+fields[i].s_name))
				return fields[i].type;
		}
	return ev_void;
}
const char *DecompileGetFieldNameIdxByFinalOffset(int ofs)
{
	int i;

	for (i = 1; i < numfielddefs; i++)
		if (fields[i].ofs == ofs) 
		{
			return fields[i].s_name+strings;
		}
	return "UNKNOWN FIELD";
}
void DecompileGetFieldNameIdxByFinalOffset2(char *out, size_t outsize, int ofs)
{
	int i;

	for (i = 1; i < numfielddefs; i++)
	{
		if (fields[i].ofs == ofs) 
		{
			QC_snprintfz(out, outsize, "%s", fields[i].s_name+strings);
			return;
		}
		else if (fields[i].type == ev_vector && fields[i].ofs+1 == ofs)
		{
			QC_snprintfz(out, outsize, "%s_y", fields[i].s_name+strings);
			return;
		}
		else if (fields[i].type == ev_vector && fields[i].ofs+2 == ofs)
		{
			QC_snprintfz(out, outsize, "%s_z", fields[i].s_name+strings);
			return;
		}
	}
	QC_snprintfz(out, outsize, "<FIELD@%i>", ofs);
}

int 
DecompileAlreadySeen(char *fname, vfile_t **rfile)
{
	int ret = 1;

	vfile_t *file;

	file = QCC_FindVFile(fname);
	if (!file)
	{
		ret = 0;
		if (rfile)
		{
			*rfile = QCC_AddVFile(fname, NULL, 0);
			AddSourceFile("progs.src",	fname);
		}
	}
	else if (rfile)
		*rfile = file;

	return ret;
}

char *DecompileReturnType(dfunction_t *df);

char *DecompileAgressiveType(dfunction_t *df, dstatement_t *last, gofs_t ofs)
{
	QCC_ddef_t *par;
	par = DecompileGetParameter(ofs);
	if (par)	//single = intended
	{
		return type_name(par);
	}

	if (ofs == ofs_return && ((last->op >= OP_CALL0 && last->op <= OP_CALL8) || (last->op >= OP_CALL1H && last->op <= OP_CALL8H)))
	{	//offset is a return value, go look at the called function's return type.
		return DecompileReturnType(functions + ((int*)pr_globals)[last->a]);
	}

	while(last >= &statements[df->first_statement])
	{
		if (last->c == ofs && 
			pr_opcodes[last->op].associative == ASSOC_LEFT &&
			pr_opcodes[last->op].priority_>0)
		{
			//previous was an operation into the temp
			return type_names[(*pr_opcodes[last->op].type_c)->type];


	//					sprintf(fname, "%s ", temp_type6(rds->a, rds, df));
		}
		last--;
	}

	return NULL;	//got to start of function... shouldn't really happen.
}

char *DecompileReturnType(dfunction_t *df)
{
	dstatement_t *ds;
	unsigned short dom;
	boolean foundret = false;
	static int recursion;
	char *ret = NULL;	//return null if we don't know.
	int couldbeastring = true;

	if (df->first_statement <= 0)
	{
		if (df->first_statement > -(int)(sizeof(builtins)/sizeof(builtins[0])))
			if (builtins[-df->first_statement].returns)
				return type_names[(*builtins[-df->first_statement].returns)->type];

		return "void";	//no returns statements found
	}

	if (rettypes[df - functions])
		return rettypes[df - functions];

	recursion++;

	ds = statements + df->first_statement;

	/*
	 * find a return statement, to determine the result type 
	 */

	while (1) 
	{
		dom = (ds->op) % OP_MARK_END_ELSE;
		if (!dom)
			break;
//		if (dom == OPQF_RETURN_V)
//			break;
		if (dom == OP_RETURN)
		{
			if (ds->a != 0)	//some code is buggy.
			{
				foundret = true;

				if (recursion < 10)
				{
					ret = DecompileAgressiveType(df, ds-1, ds->a);
					if (ret)
						break;
				}

				if (((int*)pr_globals)[ds->a] < 0 && ((int*)pr_globals)[ds->a] >= strofs)
					couldbeastring = false;	//definatly not
				else
				{
					char buf[64];
					QC_snprintfz(buf, sizeof(buf), "%f", pr_globals[ds->a]);
					if (strcmp(buf, "0.000000"))
						couldbeastring = false;	//doesn't fit the profile
				}
			}

		}
		ds++;
	}
	recursion--;

	if (foundret)
	{
		if (!ret)
		{
			if (couldbeastring)
				ret = "string /*WARNING: could not determine return type*/";
			else
				ret = "float /*WARNING: could not determine return type*/";
		}
	}
	else
		ret = "void";	//no returns statements found

	rettypes[df - functions] = ret;
	return ret;
}

void DecompileCalcProfiles(void)
{

	int i, ps;
	gofs_t j;
	char *knew;
	static char fname[512];
	static char line[512];
	dfunction_t *df;
	QCC_ddef_t *par;

	for (i = 1; i < numfunctions; i++)
	{

		df = functions + i;
		fname[0] = '\0';
		line[0] = '\0';
		DecompileProfiles[i] = NULL;

		if (df->first_statement <= 0) 
		{
			if (-df->first_statement <= sizeof(builtins)/sizeof(builtins[0]) && builtins[-df->first_statement].text)
				QC_snprintfz(fname, sizeof(fname), "%s %s", builtins[-df->first_statement].text, strings + functions[i].s_name);
			else
			{
				QC_snprintfz(fname, sizeof(fname), "__variant(...) %s", strings + functions[i].s_name);
				printf("warning: unknown builtin %s\n", strings + functions[i].s_name);
			}
		}
		else
		{
			char *rettype;

			rettype = DecompileReturnType(df);
			if (!rettype)
			{	//but we do know that it's not void
				rettype = "float /*WARNING: could not determine return type*/";
			}
			strcpy(fname, rettype);
			strcat(fname, "(");

			/*
			 * determine overall parameter size 
			 */

			for (j = 0, ps = 0; j < df->numparms; j++)
			ps += df->parm_size[j];

			if (ps > 0) 
			{
				for (j = df->parm_start; j < (df->parm_start) + ps; j++)
				{
					line[0] = '\0';
					par = DecompileGetParameter(j);
					if (!par)
						par = DecompileGetParameter((short)j);

					if (!par)
					{
						//Error("Error - No parameter names with offset %i.", j);
//						printf("No parameter names with offset %i\n", j);
						if (j < (df->parm_start) + ps - 1)
							QC_snprintfz(line, sizeof(line), "float par%i, ", j - df->parm_start);
						else
							QC_snprintfz(line, sizeof(line), "float par%i", j - df->parm_start);
					}
					else
					{
						if (par->type == ev_vector)
							j += 2;
						if (j < (df->parm_start) + ps - 1)
						{
							QC_snprintfz(line, sizeof(line), "%s, ", DecompilePrintParameter(par));
						}
						else
						{
							QC_snprintfz(line, sizeof(line), "%s", DecompilePrintParameter(par));
						}
					}
					strcat(fname, line);
				}
			}
			strcat(fname, ") ");
			line[0] = '\0';
			QC_snprintfz(line, sizeof(line), strings + functions[i].s_name);
			strcat(fname, line);

		}

		knew = (char *)malloc(strlen(fname) + 1);
		strcpy(knew, fname);
		DecompileProfiles[i] = knew;
	}

}

QCC_ddef_t *GlobalAtOffset(dfunction_t *df, gofs_t ofs)
{
	QCC_ddef_t *def;
	int i, j;

	def = globalofsdef[ofs];
	if (def)
		return def;

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if (def->ofs == ofs)
		{

			/*if (!strings[def->s_name])
			{
				char line[16];
				char *buf;

				sprintf(line, "_s_%i", def->ofs);	//globals, which are defined after the locals of the function they are first used in...
				buf = malloc(strlen(line)+1);		//must be static variables, but we can't handle them very well
				strcpy(buf, line);
				def->s_name = buf - strings;
			}*/
			globalofsdef[ofs] = def;
			return def;
		}
	}

	if (ofs >= df->parm_start && ofs < df->parm_start + df->locals)
	{
		static QCC_ddef_t parm[8];
		static char *parmnames[] = {"par0","par1","par2","par3","par4","par5","par6","par7"};
		int parmofs = ofs - df->parm_start;
		for (i = 0; i < df->numparms && i < 8; i++)
		{
			if (parmofs < df->parm_size[i])
			{
				parm[i].ofs = ofs - parmofs;
				parm[i].s_name = parmnames[i]-strings;
				parm[i].type = ev_void;

				ofs = parm[i].ofs;
				for (j = 0; j < numglobaldefs; j++)
				{
					def = &globals[j];
					if (def->ofs == ofs)
					{
						char line[256], *buf;
						sprintf(line, "%s_%c", strings+def->s_name, 'x'+parmofs);	//globals, which are defined after the locals of the function they are first used in...
						def = malloc(sizeof(*def)+strlen(line)+1);		//must be static variables, but we can't handle them very well
						buf = (char*)(def+1);
						strcpy(buf, line);
						def->s_name = buf - strings;
						def->type = ev_float;
						return def;
					}
				}

				return &parm[i];
			}
			parmofs -= df->parm_size[i];
		}
		//moo
	}
	//FIXME: if its within the current function's bounds, its:
	//	within param list: argument
	//	never written: immediate
	//	optimised: a local / locked temp.
	//	vanilla qcc: always a temp (other locals will be named)
	//elsewhere:
	//	if its assigned to somewhere, then its a temp
	//	otherwise its a const.

	return NULL;
}

char *DecompileGlobal(dfunction_t *df, gofs_t ofs, QCC_type_t * req_t)
{
	int i;
	QCC_ddef_t *def;
	static char line[8192];
	char *res;

	line[0] = '\0';

	/*if (req_t == &def_short)
	{
		QC_snprintfz(line, sizeof(line), "%ii", ofs);
		res = (char *)malloc(strlen(line) + 1);
		strcpy(res, line);
		return res;
	}*/

	def = GlobalAtOffset(df, ofs);

	if (def)
	{

		if (!strcmp(strings + def->s_name, "IMMEDIATE") || !strcmp(strings + def->s_name, ".imm"))
		{
			etype_t ty;
			if (!req_t)
				ty = def->type;
			else
			{
				ty = (etype_t)(req_t->type);
				if (!ty)
					ty = def->type;
			}
			QC_snprintfz(line, sizeof(line), "%s", DecompileValueString(ty, &pr_globals[def->ofs]));
		}
		else 
		{
			if (!strings[def->s_name])
			{
				char line[16];
				char *buf;
				QCC_ddef_t *parent;
				if (ofs >= df->parm_start && ofs < df->parm_start + df->locals)
					goto lookslikealocal;
				else if ((parent = GlobalAtOffset(df, ofs-1)) && parent->type == ev_vector)
				{	// _y
					QC_snprintfz(line, sizeof(line), "%s_y", strings+parent->s_name);	//globals, which are defined after the locals of the function they are first used in...
					buf = malloc(strlen(line)+1);		//must be static variables, but we can't handle them very well
					strcpy(buf, line);
					def->s_name = buf - strings;
				}
				else if ((parent = GlobalAtOffset(df, ofs-2)) && parent->type == ev_vector)
				{	// _z
					QC_snprintfz(line, sizeof(line), "%s_z", strings+parent->s_name);	//globals, which are defined after the locals of the function they are first used in...
					buf = malloc(strlen(line)+1);		//must be static variables, but we can't handle them very well
					strcpy(buf, line);
					def->s_name = buf - strings;
				}
				else
				{
					QC_snprintfz(line, sizeof(line), "_sloc_%i", def->ofs);	//globals, which are defined after the locals of the function they are first used in...
					buf = malloc(strlen(line)+1);		//must be static variables, but we can't handle them very well
					strcpy(buf, line);
					def->s_name = buf - strings;
				}
			}

			QC_snprintfz(line, sizeof(line), "%s", strings + def->s_name);
			if (def->type == ev_field && req_t == type_field && req_t->aux_type == type_float && DecompileGetFieldTypeByDef(def) == ev_vector)
				strcat(line, "_x");
			else if (def->type == ev_vector && req_t == type_float)
				strcat(line, "_x");

		}
		res = (char *)malloc(strlen(line) + 1);
		strcpy(res, line);

		return res;
	}

	if (ofs >= df->parm_start && ofs < df->parm_start + df->locals)
	{
		int parmofs;
lookslikealocal:
		QC_snprintfz(line, sizeof(line), "local_%i", ofs);
		for (i = 0, parmofs = ofs - df->parm_start; i < df->numparms && i < 8; i++)
		{
			if (parmofs < df->parm_size[i])
			{
				if (parmofs)
					QC_snprintfz(line, sizeof(line), "par%i_%c", i, 'x'+parmofs);
				else
					QC_snprintfz(line, sizeof(line), "par%i", i);
				break;
			}
			parmofs -= df->parm_size[i];
		}
		if (!assumelocals && i == df->numparms)
			return NULL;	//we don't know what this is. assume its a temp

		res = (char *)malloc(strlen(line) + 1);
		strcpy(res, line);
		return res;
	}

	if (assumeglobals)
	{	//unknown globals are normally assumed to be temps
		if (ofs >= ofs_parms[7]+ofs_size)
		{
			QC_snprintfz(line, sizeof(line), "tmp_%i", ofs);
			res = (char *)malloc(strlen(line) + 1);
			strcpy(res, line);

			return res;
		}
	}

	return NULL;
}

static struct
{
	char *text;
	QCC_type_t *type;
} IMMEDIATES[MAX_REGS];
gofs_t DecompileScaleIndex(dfunction_t *df, gofs_t ofs)
{
	gofs_t nofs = 0;

	/*if (ofs > ofs_parms[7]+ofs_size)
		nofs = ofs - df->parm_start + ofs_parms[7]+ofs_size;
	else*/
		nofs = ofs;

	if ((nofs < 0) || (nofs > MAX_REGS - 1))
	{
		printf("Fatal Error - Index (%i) out of bounds.\n", nofs);
		exit(1);
	}

	return nofs;
}

void DecompileImmediate_Free(void)
{
	int i;
	for (i = 0; i < MAX_REGS; i++)
	{
		if (IMMEDIATES[i].text) 
		{
			free(IMMEDIATES[i].text);
			IMMEDIATES[i].text = NULL;
		}
	}
}
void DecompileImmediate_Insert(dfunction_t *df, gofs_t ofs, char *knew, QCC_type_t *type)
{
	QCC_ddef_t *d;
	int nofs;

	nofs = DecompileScaleIndex(df, ofs);

	if (IMMEDIATES[nofs].text)
	{
//		fprintf(Decompileofile, "/*WARNING: Discarding \"%s\"/", IMMEDIATES[nofs]);
		free(IMMEDIATES[nofs].text);
		IMMEDIATES[nofs].text = NULL;
	}


	d = GlobalAtOffset(df, ofs);
	if (d && d->s_name)// && strcmp(strings+d->s_name, "IMMEDIATE"))
	{	//every operator has a src (or two) and a dest.
		//many compilers optimise by using the dest of a maths/logic operator to store to a local/global
		//they then skip off the storeopcode.
		//without this, we would never see these stores.
		IMMEDIATES[nofs].text = NULL;
		IMMEDIATES[nofs].type = NULL;

		QCC_CatVFile(Decompileofile, "%s = %s;\n", strings + d->s_name, knew);
	}
	else
	{
		IMMEDIATES[nofs].text = (char *)malloc(strlen(knew) + 1);
		strcpy(IMMEDIATES[nofs].text, knew);
		IMMEDIATES[nofs].type = type;
	}
}

char *DecompileImmediate_Get(dfunction_t *df, gofs_t ofs, QCC_type_t *req_t)
{
	char *res;
 
	gofs_t nofs;

	nofs = DecompileScaleIndex(df, ofs);
  //  printf("DecompileImmediate - Index scale: %i -> %i.\n", ofs, nofs);

	// insert at nofs 
	if (IMMEDIATES[nofs].text)
	{

	//	printf("DecompileImmediate - Reading \"%s\" at index %i.\n", IMMEDIATES[nofs], nofs);

		if (IMMEDIATES[nofs].type == type_vector && req_t == type_float)
		{
			res = (char *)malloc(strlen(IMMEDIATES[nofs].text) + 4);
			if (strchr(IMMEDIATES[nofs].text, '('))
				sprintf(res, "%s[0]", IMMEDIATES[nofs].text);
			else
				sprintf(res, "%s_x", IMMEDIATES[nofs].text);
		}
		else
		{
			res = (char *)malloc(strlen(IMMEDIATES[nofs].text) + 1);
			strcpy(res, IMMEDIATES[nofs].text);
		}

		return res;
	}
	else
	{	//you are now entering the hack zone.
		char temp[8192];
		
		switch(req_t?req_t->type:-1)
		{
		case ev_void:	//for lack of any better ideas.
		case ev_float:
			if ((float)(int)pr_globals[ofs] == pr_globals[ofs])
				QC_snprintfz(temp, sizeof(temp), "%i", (int)(pr_globals[ofs]));
			else if ((*(int*)&pr_globals[ofs] & 0x7f800000) || !(*(int*)&pr_globals[ofs] & 0x7fffffff))
				QC_snprintfz(temp, sizeof(temp), "%f", pr_globals[ofs]);
			else
				QC_snprintfz(temp, sizeof(temp), "%%%i", *(int*)&pr_globals[ofs]);
			if (pr_globals[ofs] == 0 || ((int*)pr_globals)[ofs] < 0 || ((int*)pr_globals)[ofs] >= strofs || strcmp(temp, "0.000000"))
				break;
//				printf("Hey! That's not a float! error in %s\n", strings + df->s_name);
//				printf("%f could be %s\n", pr_globals[ofs], &strings[((int*)pr_globals)[ofs]]);
		case ev_string:
			{
				const char *in;
				char *out;
				if (((int*)pr_globals)[ofs] < 0 || ((int*)pr_globals)[ofs] > strofs)
				{
					printf("Hey! That's not a string! error in %s\n", strings + df->s_name);
					QC_snprintfz(temp, sizeof(temp), "%f", pr_globals[ofs]);
					break;
				}
				in = &strings[((int*)pr_globals)[ofs]];
				out = temp;
				if (req_t->type != ev_string)
				{
					QC_snprintfz(temp, sizeof(temp), "/*%i*/", ((int*)pr_globals)[ofs]);
					out += strlen(out);
				}

				*out++ =  '\"';
				while (*in)
				{
					if (*in == '\"')
					{
						*out++ = '\\';
						*out++ = '\"';
						in++;
					}
					else if (*in == '\n')
					{
						*out++ = '\\';
						*out++ = 'n';
						in++;
					}
					else if (*in == '\\')
					{
						*out++ = '\\';
						*out++ = '\\';
						in++;
					}
					else if (*in == '\r')
					{
						*out++ = '\\';
						*out++ = 'r';
						in++;
					}
					else if (*in == '\a')
					{
						*out++ = '\\';
						*out++ = 'a';
						in++;
					}
					else if (*in == '\b')
					{
						*out++ = '\\';
						*out++ = 'b';
						in++;
					}
					else if (*in == '\f')
					{
						*out++ = '\\';
						*out++ = 'f';
						in++;
					}
					else if (*in == '\t')
					{
						*out++ = '\\';
						*out++ = 't';
						in++;
					}
					else if (*in == '\v')
					{
						*out++ = '\\';
						*out++ = 'v';
						in++;
					}
					else
						*out++ = *in++;
				}
				*out++ =  '\"';
				*out++ =  '\0';
			}
			break;
		case ev_vector:
			QC_snprintfz(temp, sizeof(temp), "\'%f %f %f\'", pr_globals[ofs],pr_globals[ofs+1],pr_globals[ofs+2]);
			break;
//		case ev_quat:
//			QC_snprintfz(temp, sizeof(temp), "\'%f %f %f %f\'", pr_globals[ofs],pr_globals[ofs+1],pr_globals[ofs+2],pr_globals[ofs+3]);
//			break;
		case ev_integer:
			QC_snprintfz(temp, sizeof(temp), "%ii", ((int*)pr_globals)[ofs]);
			break;
//		case ev_uinteger:
//			QC_snprintfz(temp, sizeof(temp), "%uu", ((int*)pr_globals)[ofs]);
//			break;
		case ev_pointer:
			QC_snprintfz(temp, sizeof(temp), "(__variant*)0x%xi", ((int*)pr_globals)[ofs]);
			break;
		case ev_function:
			if (!((int*)pr_globals)[ofs])
				QC_snprintfz(temp, sizeof(temp), "__NULL__/*func*/");
			else if (((int*)pr_globals)[ofs] > 0 && ((int*)pr_globals)[ofs] < numfunctions && functions[((int*)pr_globals)[ofs]].s_name>0)
				QC_snprintfz(temp, sizeof(temp), "%s/*immediate*/", strings+functions[((int*)pr_globals)[ofs]].s_name);
			else
				QC_snprintfz(temp, sizeof(temp), "((__variant(...))%i)", ((int*)pr_globals)[ofs]);
			break;
		case ev_entity:
			if (!pr_globals[ofs])
				QC_snprintfz(temp, sizeof(temp), "__NULL__/*entity*/");
			else
				QC_snprintfz(temp, sizeof(temp), "(entity)%i", ((int*)pr_globals)[ofs]);
			break;
		case ev_field:
			if (!pr_globals[ofs])
				QC_snprintfz(temp, sizeof(temp), "__NULL__/*field*/");
			else
				QC_snprintfz(temp, sizeof(temp), "/*field %s*/%i", DecompileGetFieldNameIdxByFinalOffset(((int*)pr_globals)[ofs]), ((int*)pr_globals)[ofs]);
			break;
		default:
			QC_snprintfz(temp, sizeof(temp), "FIXME");
			break;
		}

		res = (char *)malloc(strlen(temp) + 1);
		strcpy(res, temp);

		return res;

	}
	return NULL;
}

char *DecompileGet(dfunction_t *df, gofs_t ofs, QCC_type_t *req_t)
{
	char *farg1;
	/*if (req_t == &def_short)
	{
		char temp[16];
		QC_snprintfz(temp, sizeof(temp), "%i", ofs);
		return strdup(temp);
	}*/
	farg1 = NULL;

	farg1 = DecompileGlobal(df, ofs, req_t);

	if (farg1 == NULL)
		farg1 = DecompileImmediate_Get(df, ofs, req_t);

	return farg1;
}

void DecompilePrintStatement(dstatement_t *s);

void DecompileIndent(int c)
{
	int i;

	if (c < 0)
		c = 0;

	for (i = 0; i < c; i++) 
	{
		QCC_CatVFile(Decompileofile, "\t");
	}
}

void DecompileOpcode(dfunction_t *df, int a, int b, int c, char *opcode, QCC_type_t *typ1, QCC_type_t *typ2, QCC_type_t *typ3, int usebrackets, int *indent)
{
	static char line[512];
	char *arg1, *arg2, *arg3;
	arg1 = DecompileGet(df, a, typ1);
	arg2 = DecompileGet(df, b, typ2);
	arg3 = DecompileGlobal(df, c, typ3);

	if (arg3)
	{
		DecompileIndent(*indent);
		if (usebrackets)
			QCC_CatVFile(Decompileofile, "%s = %s %s %s;\n", arg3, arg1, opcode, arg2);
		else
			QCC_CatVFile(Decompileofile, "%s = %s%s%s;\n", arg3, arg1, opcode, arg2);
	}
	else
	{
		if (usebrackets)
			QC_snprintfz(line, sizeof(line), "(%s %s %s)", arg1, opcode, arg2);
		else
			QC_snprintfz(line, sizeof(line), "%s%s%s", arg1, opcode, arg2);
		DecompileImmediate_Insert(df, c, line, typ3);
	}
}

void DecompileDecompileStatement(dfunction_t * df, dstatement_t * s, int *indent)
{
	static char line[8192];
	static char fnam[512];
	char *arg1, *arg2, *arg3;
	int nargs, i, j;
	dstatement_t *t;
	unsigned short dom, doc, ifc, tom;
	QCC_type_t *typ1, *typ2, *typ3;
	QCC_ddef_t *par;
	dstatement_t *k;
	int dum;


	arg1 = arg2 = arg3 = NULL;

	line[0] = '\0';
	fnam[0] = '\0';

	dom = s->op;

	doc = dom / OP_MARK_END_DO;
	ifc = (dom % OP_MARK_END_DO) / OP_MARK_END_ELSE;

	// use program flow information 

	for (i = 0; i < ifc; i++) 
	{
		(*indent)--;
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "}\n");//FrikaC style modification
	}
	for (i = 0; i < doc; i++) 
	{
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "do\n");
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "{\n");
		(*indent)++;
	}

	/*
	 * remove all program flow information 
	 */
	s->op %= OP_MARK_END_ELSE;
	typ1 = pr_opcodes[s->op].type_a?*pr_opcodes[s->op].type_a:NULL;
	typ2 = pr_opcodes[s->op].type_b?*pr_opcodes[s->op].type_b:NULL;
	typ3 = pr_opcodes[s->op].type_c?*pr_opcodes[s->op].type_c:NULL;

	/*
	 * printf("DecompileDecompileStatement - decompiling %i (%i):\n",(int)(s - statements),dom);
	 * DecompilePrintStatement (s);  
	 */
	/*
	 * states are handled at top level 
	 */
	if (s->op == OP_DONE)
	{

	}
	else if (s->op == OP_BOUNDCHECK)
	{
		/*these are auto-generated as a sideeffect. currently there is no syntax to explicitly use one (other than asm), but we don't want to polute the code when they're autogenerated, so ditch them all*/
	}
	else if (s->op == OP_STATE) 
	{

		par = DecompileGetParameter(s->a);
		if (!par)
		{
			printf("Error - Can't determine frame number.\n");
			exit(1);
		}
		arg2 = DecompileGet(df, s->b, NULL);
		if (!arg2)
		{
			printf("Error - No state parameter with offset %i.\n", s->b);
			exit(1);
		}
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "state [ %s, %s ];\n", DecompileValueString((etype_t)(par->type), &pr_globals[par->ofs]), arg2);

	//	free(arg2);
	}
	else if (s->op == OP_RETURN/* || s->op == OPQF_RETURN_V*/)
	{
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "return");

		if (s->a)
		{
			QCC_CatVFile(Decompileofile, " ");
			arg1 = DecompileGet(df, s->a, type_void);	//FIXME: we should know the proper type better than this.
			QCC_CatVFile(Decompileofile, "(%s)", arg1);
		}
		QCC_CatVFile(Decompileofile, ";\n");

	}
	else if ((OP_MUL_F <= s->op && s->op <= OP_SUB_V) ||
		(OP_EQ_F <= s->op && s->op <= OP_GT_F) ||
		(OP_AND_F <= s->op && s->op <= OP_BITOR_F)
		/*|| pr_opcodes[s->op].associative == ASSOC_LEFT*/)
	{
		DecompileOpcode(df, s->a, s->b, s->c, pr_opcodes[s->op].name, typ1, typ2, typ3, true, indent);
	}
	else if (OP_GLOBALADDRESS == s->op)
	{
		arg1 = DecompileGet(df, s->a, typ1);
		arg2 = DecompileGet(df, s->b, typ2);
		arg3 = DecompileGlobal(df, s->c, typ3);

		if (arg3)
		{
			DecompileIndent(*indent);
			if (s->b)
				QCC_CatVFile(Decompileofile, "%s = &%s[%s];\n", arg3, arg1, arg2);
			else
				QCC_CatVFile(Decompileofile, "%s = &%s;\n", arg3, arg1);
		}
		else
		{
			if (s->b)
				QC_snprintfz(line, sizeof(line), "%s[%s]", arg1, arg2);
			else
				QC_snprintfz(line, sizeof(line), "%s", arg1);
			DecompileImmediate_Insert(df, s->c, line, typ3);
		}
	}
	else if ((OP_LOAD_F <= s->op && s->op <= OP_ADDRESS) || s->op == OP_LOAD_P || s->op == OP_LOAD_I)
	{
		if (s->op == OP_ADDRESS)
		{
			QCC_ddef_t *def = GlobalAtOffset(df, s->b);
			if (def && DecompileGetFieldTypeByDef(def) == ev_vector)
				typ3 = type_vector;
		}

		type_field->aux_type = typ3;
		DecompileOpcode(df, s->a, s->b, s->c, ".", typ1, typ2, typ3, false, indent);
		type_field->aux_type = NULL;
	}
	else if ((OP_LOADA_F <= s->op && s->op <= OP_LOADA_I))// || (OPQF_LOADBI_F <= s->op && s->op <= OPQF_LOADBI_P))
	{
		static char line[512];
		char *arg1, *arg2, *arg3;
		arg1 = DecompileGet(df, s->a, typ1);
		arg2 = DecompileGet(df, s->b, typ2);
		arg3 = DecompileGlobal(df, s->c, typ3);

		if (arg3) 
		{
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "%s = %s[%s];\n", arg3, arg1, arg2);
		}
		else
		{
			QC_snprintfz(line, sizeof(line), "%s[%s]", arg1, arg2);
			DecompileImmediate_Insert(df, s->c, line, typ3);
		}
	}
	else if ((OP_STORE_F <= s->op && s->op <= OP_STORE_FNC) || s->op == OP_STORE_I || s->op == OP_STORE_P)
	{
		QCC_type_t *parmtype=NULL;
		if (s->b >= ofs_parms[0] && s->b < ofs_parms[7]+ofs_size)
		{	//okay, so typ1 might not be what the store type says it should be.
			k = s+1;
			while(k->op%OP_MARK_END_ELSE)
			{
				if ((k->op >= OP_CALL0 && k->op <= OP_CALL8) || (k->op >= OP_CALL1H && k->op <= OP_CALL8H))
				{
					//well, this is it.
					int fn;
					int pn;
					dfunction_t *cf;
					QCC_ddef_t *def;
					fn = ((int*)pr_globals)[k->a];
					cf = &functions[fn];
					if (cf->first_statement<=0 && cf->first_statement > -(signed)(sizeof(builtins)/sizeof(builtins[0])))	//builtins don't have this info.
					{
						QCC_type_t **p = builtins[-cf->first_statement].params[(s->b-ofs_parms[0])/ofs_size];
						parmtype = p?*p:NULL;
					}
					else
					{
						fn = cf->parm_start;
						for (pn = 0; pn < (s->b-ofs_parms[0])/ofs_size; pn++)
							fn += cf->parm_size[pn];

						def = DecompileGetParameter(fn);
						if (def)
						{
							switch(def->type)
							{
							case ev_float:
								parmtype = type_float;
								break;
							case ev_string:
								parmtype = type_string;
								break;
							case ev_vector:
								parmtype = type_vector;
								break;
							case ev_entity:
								parmtype = type_entity;
								break;
							case ev_function:
								parmtype = type_function;
								break;
							case ev_integer:
								parmtype = type_integer;
								break;
//							case ev_uinteger:
//								parmtype = type_uinteger;
//								break;
//							case ev_quat:
//								parmtype = type_quat;
//								break;
							default:
//								parmtype = type_float;
								break;
							}
						}
					}
					break;
				}
				else if (OP_STORE_F <= s->op && s->op <= OP_STORE_FNC)
				{
					if (k->b < s->b)	//whoops... older QCCs can nest things awkwardly.
						break;
				}
				k++;
			}
		}

		if (parmtype)
			arg1 = DecompileGet(df, s->a, parmtype);
		else
			arg1 = DecompileGet(df, s->a, typ1);
		arg3 = DecompileGlobal(df, s->b, typ2);

		if (arg3)
		{
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "%s = %s;\n", arg3, arg1);
		}
		else
		{
			QC_snprintfz(line, sizeof(line), "%s", arg1);
			DecompileImmediate_Insert(df, s->b, line, NULL);
		}

	}
	else if (OP_STOREP_F <= s->op && s->op <= OP_STOREP_FNC)
	{
		arg1 = DecompileGet(df, s->a, typ2);
		//FIXME: we need to deal with ref types and other crazyness, so we know whether we need to add * or *& or if we can skip that completely
		arg2 = DecompileGet(df, s->b, typ2);

		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "%s = %s;\n", arg2, arg1);

	}
	else if (OP_CONV_FTOI == s->op)
	{

		arg1 = DecompileGet(df, s->a, typ1);
		QC_snprintfz(line, sizeof(line), "(int)%s", arg1);
		DecompileImmediate_Insert(df, s->c, line, type_integer);

	}
	else if (OP_RAND0 == s->op)
	{
		DecompileImmediate_Insert(df, ofs_return, "random()", type_float);
	}
	else if (OP_RAND1 == s->op)
	{
		arg1 = DecompileGet(df, s->a, typ1);
		QC_snprintfz(line, sizeof(line), "random(%s)", arg1);
		DecompileImmediate_Insert(df, ofs_return, line, type_float);
	}
	else if (OP_RAND2 == s->op)
	{
		arg1 = DecompileGet(df, s->a, typ1);
		arg2 = DecompileGet(df, s->b, typ2);
		QC_snprintfz(line, sizeof(line), "random(%s, %s)", arg1, arg2);
		DecompileImmediate_Insert(df, ofs_return, line, type_float);
	}
	else if (OP_NOT_F <= s->op && s->op <= OP_NOT_FNC)
	{

		arg1 = DecompileGet(df, s->a, typ1);
		QC_snprintfz(line, sizeof(line), "!%s", arg1);
		DecompileImmediate_Insert(df, s->c, line, type_float);

	}
	else if ((OP_CALL0 <= s->op && s->op <= OP_CALL8) || (OP_CALL1H <= s->op && s->op <= OP_CALL8H))
	{
		if (OP_CALL1H <= s->op && s->op <= OP_CALL8H)
			nargs = (s->op - OP_CALL1H) + 1;
		else
			nargs = s->op - OP_CALL0;

		arg1 = DecompileGet(df, s->a, type_function);
		QC_snprintfz(line, sizeof(line), "%s(", arg1);
		QC_snprintfz(fnam, sizeof(fnam), "%s", arg1);

		for (i = 0; i < nargs; i++)
		{

			typ1 = NULL;

			if (i == 0 && OP_CALL1H <= s->op && s->op <= OP_CALL8H)
				j = s->b;
			else if (i == 1 && OP_CALL1H <= s->op && s->op <= OP_CALL8H)
				j = s->c;
			else
				j = ofs_parms[i];

			if (arg1)
			free(arg1);

			arg1 = DecompileGet(df, (gofs_t)j, typ1);
			strcat(line, arg1);

			if (i < nargs - 1)
				strcat(line, ", ");//frikqcc modified
		}

		strcat(line, ")");
		DecompileImmediate_Insert(df, ofs_return, line, NULL);

	/*
	 * if ( ( ( (s+1)->a != 1) && ( (s+1)->b != 1) && 
	 * ( (s+2)->a != 1) && ( (s+2)->b != 1) ) || 
	 * ( ((s+1)->op) % OP_MARK_END_ELSE == OP_CALL0 ) ) {
	 * DecompileIndent(*indent);
	 * fprintf(Decompileofile,"%s;\n",line);
	 * }
	 */

		if ((((s + 1)->a != ofs_return) && ((s + 1)->b != ofs_return) &&
			((s + 2)->a != ofs_return) && ((s + 2)->b != ofs_return)) ||
			((((s + 1)->op) % OP_MARK_END_ELSE == OP_CALL0) && ((((s + 2)->a != ofs_return)) || ((s + 2)->b != ofs_return))))
		{
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "%s;\n", line);
		}
	}
	else if (s->op == OP_IF_I || s->op == OP_IFNOT_I || s->op == OP_IF_F || s->op == OP_IFNOT_F/* || s->op == OPQF_IFA || s->op == OPQF_IFB || s->op == OPQF_IFAE || s->op == OPQF_IFBE*/)
	{

		arg1 = DecompileGet(df, s->a, type_float);	//FIXME: this isn't quite accurate...
		arg2 = DecompileGlobal(df, s->a, NULL);

		if (s->op == OP_IFNOT_I || s->op == OP_IFNOT_F)
		{
	lameifnot:
			if ((signed int)s->b < 1)
			{
//				if (arg1)
//					free(arg1);
//				if (arg2)
//					free(arg2);
//				if (arg3)
//					free(arg3);

				return;


				printf("Found a negative IFNOT jump.\n");
				exit(1);
			}

			/*
			 * get instruction right before the target 
			 */
			t = s + (signed int)s->b - 1;
			tom = t->op % OP_MARK_END_ELSE;

			if (tom != OP_GOTO)
			{

				/*
				 * pure if 
				 */
				DecompileIndent(*indent);
				QCC_CatVFile(Decompileofile, "if (%s)\n", arg1);//FrikaC modified
				DecompileIndent(*indent);
				QCC_CatVFile(Decompileofile, "{\n");

				(*indent)++;

			}
			else
			{
			
				if ((signed int)t->a > 0)
				{
					/*
					 * ite 
					 */

					DecompileIndent(*indent);
					QCC_CatVFile(Decompileofile, "if (%s)\n", arg1);//FrikaC modified
					DecompileIndent(*indent);
					QCC_CatVFile(Decompileofile, "{\n");

					(*indent)++;

				}
				else
				{


					if (((signed int)t->a + (signed int)s->b) > 1)
					{
						/*
						 * pure if  
						 */

						DecompileIndent(*indent);
						QCC_CatVFile(Decompileofile, "if (%s)\n", arg1);//FrikaC modified
						DecompileIndent(*indent);
						QCC_CatVFile(Decompileofile, "{\n");
						(*indent)++;
					}
					else
					{

						dum = 1;
						for (k = t + (signed int)(t->a); k < s; k++)
						{
							tom = k->op % OP_MARK_END_ELSE;
							if (tom == OP_GOTO || tom == OP_IF_I || tom == OP_IFNOT_I || tom == OP_IF_F || tom == OP_IFNOT_F)
								dum = 0;
						}
						if (dum) 
						{

							DecompileIndent(*indent);
							QCC_CatVFile(Decompileofile, "while (%s)\n", arg1);
							DecompileIndent(*indent); //FrikaC
							QCC_CatVFile(Decompileofile, "{\n");
							(*indent)++;
						}
						else
						{

							DecompileIndent(*indent);


							QCC_CatVFile(Decompileofile, "if (%s)\n", arg1);//FrikaC modified
							DecompileIndent(*indent);
							QCC_CatVFile(Decompileofile, "{\n");
							(*indent)++;
						}
					}
				}
			}
		}
		/*else if (s->op == OPQF_IFA)
		{
			char *t = arg1;
			arg1 = malloc(strlen(arg1)+8);
			sprintf(arg1, "(%s) <= 0", t);
			free(t);
			goto lameifnot;
		}
		else if (s->op == OPQF_IFAE)
		{
			char *t = arg1;
			arg1 = malloc(strlen(arg1)+7);
			sprintf(arg1, "(%s) < 0", t);
			free(t);
			goto lameifnot;
		}
		else if (s->op == OPQF_IFB)
		{
			char *t = arg1;
			arg1 = malloc(strlen(arg1)+8);
			sprintf(arg1, "(%s) >= 0", t);
			free(t);
			goto lameifnot;
		}
		else if (s->op == OPQF_IFBE)
		{
			char *t = arg1;
			arg1 = malloc(strlen(arg1)+7);
			sprintf(arg1, "(%s) > 0", t);
			free(t);
			goto lameifnot;
		}*/
		else
		{
			if ((signed int)s->b>0)
			{
				char *t = arg1;
				//if (!...)

				arg1 = malloc(strlen(arg1)+2);
				sprintf(arg1, "!%s", t);
				free(t);
				goto lameifnot;
			}
			else
			{
			/*
			 * do ... while 
			 */

				(*indent)--;
				QCC_CatVFile(Decompileofile, "\n");
				DecompileIndent(*indent);
				QCC_CatVFile(Decompileofile, "} while (%s);\n", arg1);
			}

		}

	}
	else if (s->op == OPF_FORSTART)
	{
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "do_tail\n", (s-statements) + (signed int)s->a);
		DecompileIndent(*indent);
		QCC_CatVFile(Decompileofile, "{\n");
		(*indent)++;
	}
	else if (s->op == OP_GOTO)
	{

		if ((signed int)s->a > 0)
		{
			/*
			 * else 
			 */
			(*indent)--;
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "}\n");
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "else\n");
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "{\n");
			(*indent)++;

		}
		else
		{
			/*
			 * while 
			 */
			(*indent)--;

			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "}\n");

		}

	}
	else
	{
		int op = s->op%OP_MARK_END_ELSE;
		if (op <= OP_BITOR_F && pr_opcodes[s->op].opname)
			printf("warning: Unknown usage of OP_%s", pr_opcodes[s->op].opname);
		else
		{
			DecompileIndent(*indent);
			QCC_CatVFile(Decompileofile, "[OP_%s", pr_opcodes[op].opname);
			if (s->a)
				QCC_CatVFile(Decompileofile, ", %s", DecompileGet(df, s->a, typ1));
			if (s->b)
				QCC_CatVFile(Decompileofile, ", %s", DecompileGet(df, s->b, typ1));
			if (s->c)
				QCC_CatVFile(Decompileofile, ", %s", DecompileGet(df, s->c, typ1));
			QCC_CatVFile(Decompileofile, "]\n");
			printf("warning: Unknown opcode %i in %s\n", op, strings + df->s_name);
		}

	}


//    printf("DecompileDecompileStatement - Current line is \"%s\"\n", line);


	if (arg1)
		free(arg1);
	if (arg2)
		free(arg2);
	if (arg3)
		free(arg3);

	return;
}

boolean DecompileDecompileFunction(dfunction_t * df, dstatement_t *altdone)
{
	dstatement_t *ds;
	int indent;


	// Initialize 
 
	DecompileImmediate_Free();

	indent = 1;

	ds = statements + df->first_statement;
	if(ds->op == OP_STATE)
		ds++;
	while (1) 
	{
		if (ds == altdone)
		{
			//decompile the dummy done, cos we can
			DecompileDecompileStatement(df, statements, &indent);
			break;
		}
		DecompileDecompileStatement(df, ds, &indent);
		if (!ds->op)
			break;
		ds++;
	}

	if (indent != 1)
	{
		printf("warning: Indentation structure corrupt (in func %s)\n", strings+df->s_name);
		return false;
	}
	return true;
}

char *DecompileString(int qcstring)
{
	static char buf[8192];
	char *s;
	int c = 1;
	const char *string = strings+qcstring;
	if (qcstring < 0 || qcstring >= strofs)
		return "Invalid String";

	s = buf;
	*s++ = '"';
	while (string && *string)
	{
		if (c == sizeof(buf) - 2)
			break;
		if (*string == '\n')
		{
			*s++ = '\\';
			*s++ = 'n';
			c++;
		}
		else if (*string == '"')
		{
			*s++ = '\\';
			*s++ = '"';
			c++;
		}
		else
		{
			*s++ = *string;
			c++;
		}
		string++;
		if (c > (int)(sizeof(buf) - 10))
		{
			*s++ = '.';
			*s++ = '.';
			*s++ = '.';
			c += 3;
			break;
		}
	}
	*s++ = '"';
	*s++ = 0;
	return buf;
}

char *DecompileValueString(etype_t type, void *val)
{
	static char line[8192];

	line[0] = '\0';

	switch (type)
	{
		case ev_string:
			QC_snprintfz(line, sizeof(line), "%s", DecompileString(*(int *)val));
			break;
		case ev_void:
			QC_snprintfz(line, sizeof(line), "void");
			break;
		case ev_float:
			if (*(float *)val > 999999 || *(float *)val < -999999) // ugh
				QC_snprintfz(line, sizeof(line), "%.f", *(float *)val);
			else if ((!(*(int*)val & 0x7f800000) || (*(int*)val & 0x7f800000)==0x7f800000) && (*(int*)val & 0x7fffffff))
				QC_snprintfz(line, sizeof(line), "%%%i", *(int*)val);
			else if ((*(float *)val < 0.001) && (*(float *)val > 0))
				QC_snprintfz(line, sizeof(line), "%.6f", *(float *)val);
			else			
				QC_snprintfz(line, sizeof(line), "%g", *(float *)val);
			break;
		case ev_vector:
			QC_snprintfz(line, sizeof(line), "'%g %g %g'", ((float *)val)[0], ((float *)val)[1], ((float *)val)[2]);
			break;
//		case ev_quat:
//			QC_snprintfz(line, sizeof(line), "'%g %g %g %g'", ((float *)val)[0], ((float *)val)[1], ((float *)val)[2], ((float *)val)[3]);
//			break;
		case ev_field:
			DecompileGetFieldNameIdxByFinalOffset2(line, sizeof(line), *(int *)val);
			break;
		case ev_entity:
			QC_snprintfz(line, sizeof(line), "(entity)%ii", *(int *)val);
			break;
		case ev_integer:
			QC_snprintfz(line, sizeof(line), "%ii", *(int *)val);
			break;
//		case ev_uinteger:
//			QC_snprintfz(line, sizeof(line), "%uu", *(int *)val);
//			break;
		case ev_pointer:
			QC_snprintfz(line, sizeof(line), "(__variant*)0x%xi", *(int *)val);
			break;
		default:
			QC_snprintfz(line, sizeof(line), "bad type %i", type);
			break;
	}

	return line;
}

char *DecompilePrintParameter(QCC_ddef_t * def)
{
	static char line[128];
	static char debug[128];

	line[0] = '0';

	if (debug_offs)
	{
		QC_snprintfz(debug, sizeof(debug), " /*@%i*/", def->ofs);
	}
	else
		*debug = 0;

	if (!strings[def->s_name])	//null string...
	{
		QC_snprintfz(line, sizeof(line), "%s _p_%i%s", type_name(def), def->ofs, debug);
	}
	else if (!strcmp(strings + def->s_name, "IMMEDIATE") || !strcmp(strings + def->s_name, ".imm"))
	{
		QC_snprintfz(line, sizeof(line), "%s%s", DecompileValueString((etype_t)(def->type), &pr_globals[def->ofs]), debug);
	}
	else
	{
		QC_snprintfz(line, sizeof(line), "%s %s%s", type_name(def), strings + def->s_name, debug);
	}
	return line;
}

//we only work with prior fields.
const char *GetMatchingField(QCC_ddef_t *field)
{
	int i;
	QCC_ddef_t *def;
	int ld, lf;

	def = NULL;

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if ((def->type&~DEF_SAVEGLOBAL) == ev_field)
		{
			if (((int*)pr_globals)[def->ofs] == field->ofs)
			{
				if (!strcmp(strings+def->s_name, strings+field->s_name))
					break;	//found ourself, give up.
				lf = strlen(strings + field->s_name);
				ld = strlen(strings + def->s_name);
				if (lf - 2 == ld)
				{
					if ((strings + field->s_name)[lf-2] == '_')
						if (!strncmp(strings + field->s_name, strings + def->s_name, ld))
							break;
				}
				return def->s_name+strings;
			}
		}
	}

	return NULL;
}

QCC_ddef_t *GetField(const char *name)
{
	int i;
	QCC_ddef_t *d;
	if (!*name)
		return NULL;

	for (i = 0; i < numfielddefs; i++)
	{
		d = &fields[i];

		if (!strcmp(strings + d->s_name, name))
			return d;
	}
	return NULL;
}
QCC_ddef_t *DecompileGetParameter(gofs_t ofs)
{
	int i;
	QCC_ddef_t *def;

	def = NULL;

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if (def->ofs == ofs)
		{
			return def;
		}
	}

	return NULL;
}
QCC_ddef_t *DecompileFindGlobal(const char *findname)
{
	int i;
	QCC_ddef_t *def;
	const char *defname;

	def = NULL;

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];
		defname = strings + def->s_name;

		if (!strcmp(findname, defname))
		{
			return def;
		}
	}

	return NULL;
}

QCC_ddef_t *DecompileFunctionGlobal(int funcnum)
{
	int i;
	QCC_ddef_t *def;

	def = NULL;

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if (def->type == ev_function)
		{
			if (((int*)pr_globals)[def->ofs] == funcnum)
			{
				return def;
			}
		}
	}

	return NULL;
}

void DecompileFunction(const char *name, int *lastglobal)
{
	int i, findex, ps;
	dstatement_t *ds, *ts, *altdone;
	dfunction_t *df;
	QCC_ddef_t *par;
	char *arg2;
	unsigned short dom, tom;
	int j, start, end;
	QCC_ddef_t *ef;
	static char line[8192];
	dstatement_t *k;
	int dum;
	size_t startpos;

	const char *matchingfield;

	for (i = 1; i < numfunctions; i++)
		if (!strcmp(name, strings + functions[i].s_name))
			break;
	if (i == numfunctions)
	{
		printf("Fatal Error: No function named \"%s\"\n", name);
		exit(1);
	}
	df = functions + i;
	altdone = statements + numstatements;
	for (j = i+1; j < numfunctions; j++)
	{
		if (functions[j].first_statement <= 0)
			continue;
		altdone = statements + functions[j].first_statement;
		break;
	}

	findex = i;

	start = *lastglobal;

//    if (dfpred->first_statement <= 0 && df->first_statement > 0)
//		start -= 1;

	end = df->parm_start;
	if (!end)
	{
		par = DecompileFindGlobal(name);
		if (par)
			end = par - globals;
	}
	*lastglobal = max(*lastglobal, end + df->locals);

	//print globals leading up to the function.
	for (j = start; j < end; j++)
	{

		par = DecompileGetParameter((gofs_t)j);

		if (par)
		{
			if (par->type & DEF_SAVEGLOBAL)
				par->type -= DEF_SAVEGLOBAL;

			if (par->type == ev_function)
			{
				if (strcmp(strings + par->s_name, "IMMEDIATE") && strcmp(strings + par->s_name, ".imm"))
				{
					if (strcmp(strings + par->s_name, name))
					{
						int f = ((int*)pr_globals)[par->ofs];
						//DecompileGetFunctionIdxByName(strings + par->s_name);
						if (f && strcmp(strings+functions[f].s_name, strings + par->s_name))
						{
							char *s = strrchr(DecompileProfiles[f], ' ');
							//happens with void() func = otherfunc;
							//such functions thus don't have their own type+body
							*s = 0;
							QCC_CatVFile(Decompileofile, "var %s %s = %s;\n", DecompileProfiles[f], strings + par->s_name, s+1);
							*s = ' ';
						}
						else
							QCC_CatVFile(Decompileofile, "%s;\n", DecompileProfiles[f]);
					}
				}
			}
			else if (par->type != ev_pointer)
			{
				if (strcmp(strings + par->s_name, "IMMEDIATE") && strcmp(strings + par->s_name, ".imm"))
				{

					if (par->type == ev_field)
					{

						ef = GetField(strings + par->s_name);

						if (!ef)
						{
							QCC_CatVFile(Decompileofile, "var .unknowntype %s;\n", strings + par->s_name);
							printf("Fatal Error: Could not locate a field named \"%s\"\n", strings + par->s_name);
						}
						else
						{
							//if (ef->type == ev_vector)
							//	j += 2;

							matchingfield = GetMatchingField(ef);

#ifndef DONT_USE_DIRTY_TRICKS	//could try scanning for an op_address+op_storep_fnc pair
							if ((ef->type == ev_function) && !strcmp(strings + ef->s_name, "th_pain"))
							{
								QCC_CatVFile(Decompileofile, ".void(entity attacker, float damage) th_pain;\n");
							}
							else
#endif
							{
								if (matchingfield)
									QCC_CatVFile(Decompileofile, "var .%s %s = %s;\n", type_name(ef), strings + ef->s_name, matchingfield);
								else
									QCC_CatVFile(Decompileofile, ".%s %s;\n", type_name(ef), strings + ef->s_name);

//								fprintf(Decompileofile, "//%i %i %i %i\n", ef->ofs, ((int*)pr_globals)[ef->ofs], par->ofs, ((int*)pr_globals)[par->ofs]);
							}
						}
					}
					else
					{

						if (par->type == ev_vector)
							j += 2;

						if (par->type == ev_entity || par->type == ev_void)
						{

							QCC_CatVFile(Decompileofile, "%s %s;\n", type_name(par), strings + par->s_name);

						}
						else
						{

							line[0] = '\0';
							QC_snprintfz(line, sizeof(line), "%s", DecompileValueString((etype_t)(par->type), &pr_globals[par->ofs]));

							if (IsConstant(par))
							{
								QCC_CatVFile(Decompileofile, "%s %s    = %s;\n", type_name(par), strings + par->s_name, line);
							}
							else
							{
								if (pr_globals[par->ofs] != 0)
									QCC_CatVFile(Decompileofile, "%s %s /* = %s */;\n", type_name(par), strings + par->s_name, line);
								else
									QCC_CatVFile(Decompileofile, "%s %s;\n", type_name(par), strings + par->s_name, line);
							}
						}
					}
				}
			}
		}
	}
	/*
	 * Check ''local globals'' 
	 */

	if (df->first_statement <= 0)
	{

		QCC_CatVFile(Decompileofile, "%s", DecompileProfiles[findex]);
		QCC_CatVFile(Decompileofile, " = #%i; \n", -df->first_statement);

		return;
	}
	ds = statements + df->first_statement;

	while (1)
	{

		dom = (ds->op) % OP_MARK_END_ELSE;

		if (!dom || ds == altdone)
			break;
		else if (dom == OP_GOTO)
		{
			// check for i-t-e 
			if ((signed int)ds->a > 0)
			{
				ts = ds + (signed int)ds->a;
				ts->op += OP_MARK_END_ELSE;	// mark the end of a if/ite construct 
			}
		}
		else if (dom == OP_IFNOT_I || dom == OP_IFNOT_F || dom == OP_IFNOT_S)
		{
			// check for pure if 

			ts = ds + (signed int)ds->b;
			tom = (ts - 1)->op % OP_MARK_END_ELSE;

			if (tom != OP_GOTO)
				ts->op += OP_MARK_END_ELSE;	// mark the end of a if construct 
			else if ((signed int)(ts - 1)->a < 0)
			{
				if (((signed int)(ts - 1)->a + (signed int)ds->b) > 1)
				{
					// pure if
					ts->op += OP_MARK_END_ELSE;	// mark the end of a if/ite construct 
				}
				else
				{

					dum = 1;
					for (k = (ts - 1) + (signed int)((ts - 1)->a); k < ds; k++)
					{
						tom = k->op % OP_MARK_END_ELSE;
						if (tom == OP_GOTO || tom == OP_IF_I || tom == OP_IFNOT_I || tom == OP_IF_F || tom == OP_IFNOT_F)
							dum = 0;
					}
					if (!dum)
					{
						// pure if  
						ts->op += OP_MARK_END_ELSE;	// mark the end of a if/ite construct 
					}
				}
			}
		}
		else if (dom == OP_IF_I || dom == OP_IF_F || dom == OP_IF_S)
		{
			if ((signed int)ds->b<1)
			{
				ts = ds + (signed int)ds->b;
				//this is some kind of loop, either a while or for.

				//if the statement before the 'do' is a forwards goto, and it jumps to within the loop (instead of after), then we have to assume that it is a for loop and not a loop inside an else block.
				if ((ts-1)->op%OP_MARK_END_ELSE == OP_GOTO && (signed int)(ts-1)->a > 0 && (ts-1)+(signed int)(ts-1)->a <= ds)
				{
					(--ts)->op += OPF_FORSTART - OP_GOTO;
					//because it was earlier, we need to unmark that goto's target as an end_else
					ts = ts + (signed int)ts->a;
					ts->op -= OP_MARK_END_ELSE;
				}
				else
					ts->op += OP_MARK_END_DO;	// mark the start of a do construct 
			}
			else
			{
				ts = ds + ds->b;
				if ((ts-1)->op%OP_MARK_END_ELSE != OP_GOTO)
					ts->op += OP_MARK_END_ELSE;	// mark the end of an if construct 
				else if ((signed int)(ts - 1)->a < 0)
				{
					if (((signed int)(ts - 1)->a + (signed int)ds->b) > 1)
					{
						// pure if
						ts->op += OP_MARK_END_ELSE;	// mark the end of a if/ite construct 
					}
					else
					{

						dum = 1;
						for (k = (ts - 1) + (signed int)((ts - 1)->a); k < ds; k++)
						{
							tom = k->op % OP_MARK_END_ELSE;
							if (tom == OP_GOTO || tom == OP_IF_I || tom == OP_IFNOT_I || tom == OP_IF_F || tom == OP_IFNOT_F)
								dum = 0;
						}
						if (!dum)
						{
							// pure if  
							ts->op += OP_MARK_END_ELSE;	// mark the end of a if/ite construct 
						}
					}
				}
			}
		}
		ds++;
	}

	/*
	 * print the prototype 
	 */
	QCC_CatVFile(Decompileofile, "\n%s", DecompileProfiles[findex]);

	// handle state functions 

	ds = statements + df->first_statement;

	if (ds->op == OP_STATE)
	{

		par = DecompileGetParameter(ds->a);
		if (!par)
		{
			static QCC_ddef_t pars;
			//must be a global (gotta be a float), create the def as needed
			pars.ofs = ds->a;
			pars.s_name = "IMMEDIATE"-strings;
			pars.type = ev_float;
			par = &pars;
//			printf("Fatal Error - Can't determine frame number.");
//			exit(1);
		}

		arg2 = DecompileGet(df, ds->b, NULL);
		if (!arg2)
		{
			printf("Fatal Error - No state parameter with offset %i.", ds->b);
			exit(1);
		}

		QCC_CatVFile(Decompileofile, " = [ %s, %s ]", DecompileValueString((etype_t)(par->type), &pr_globals[par->ofs]), arg2);

		free(arg2);

	}
	else
	{
		QCC_CatVFile(Decompileofile, " =");
	}
	QCC_CatVFile(Decompileofile, "\n{\n");

	startpos = Decompileofile->fsize;

/*
	fprintf(Decompileprofile, "%s", DecompileProfiles[findex]);
	fprintf(Decompileprofile, ") %s;\n", name);
*/

	/*
	 * calculate the parameter size 
	 */

	for (j = 0, ps = 0; j < df->numparms; j++)
	{
		par = DecompileGetParameter((gofs_t)(df->parm_start + ps));

		if (par)
		{
			if (!strings[par->s_name])
			{
				QC_snprintfz(line, sizeof(line), "_p_%i", par->ofs);
				arg2 = malloc(strlen(line)+1);
				strcpy(arg2, line);
				par->s_name = arg2 - strings;
			}
		}

		ps += df->parm_size[j];
	}

	/*
	 * print the locals 
	 */

	if (df->locals > 0)
	{

		if ((df->parm_start) + df->locals - 1 >= (df->parm_start) + ps)
		{

			for (i = df->parm_start + ps; i < (df->parm_start) + df->locals; i++) 
			{

				par = DecompileGetParameter((gofs_t)i);

				if (!par)
				{
					// temps, or stripped...
					continue;
				}
				else
				{
					if (!strcmp(strings + par->s_name, "IMMEDIATE") || !strcmp(strings + par->s_name, ".imm"))
						continue; // immediates don't belong

					if (!strings[par->s_name])
					{
						QC_snprintfz(line, sizeof(line), "_l_%i", par->ofs);
						arg2 = malloc(strlen(line)+1);
						strcpy(arg2, line);
						par->s_name = arg2 - strings;
					}

					if (par->type == ev_function)
					{
						printf("Warning Fields and functions must be global\n");
					}
					else
					{
						if (((int*)pr_globals)[par->ofs])
							QCC_CatVFile(Decompileofile, "\tlocal %s = %s;\n", DecompilePrintParameter(par), DecompileValueString(par->type, &pr_globals[par->ofs]));
						else
							QCC_CatVFile(Decompileofile, "\tlocal %s;\n", DecompilePrintParameter(par));
					}
					if (par->type == ev_vector)
						i += 2;
				}
			}

			QCC_CatVFile(Decompileofile, "\n");

		}
	}
	/*
	 * do the hard work 
	 */

	if (!DecompileDecompileFunction(df, altdone))
	{
		QCC_InsertVFile(Decompileofile, startpos, "#error Corrupt Function: %s\n#if 0\n", strings+df->s_name);
		QCC_CatVFile(Decompileofile, "#endif\n");
	}

	QCC_CatVFile(Decompileofile, "};\n");
}

extern boolean safedecomp;
int fake_name;
char synth_name[1024]; // fake name part2

boolean TrySynthName(const char *first)
{
	int i;

	// try to figure out the filename
	// based on the first function in the file
	for (i=0; i < FILELISTSIZE; i+=2)
	{
		if (!strcmp(filenames[i], first))
		{
			QC_snprintfz(synth_name, sizeof(synth_name), filenames[i + 1]);
			return true;
		}
	}
	return false;
}

void DecompileDecompileFunctions(const char *origcopyright)
{
	int i;
	unsigned int o;
	dfunction_t *d;
	boolean bogusname;
	vfile_t *f;
	char fname[512];
	int lastglob = 1;

	DecompileCalcProfiles();

	AddSourceFile(NULL, "progs.src");
	Decompileprogssrc = QCC_AddVFile("progs.src", NULL, 0);
	if (!Decompileprogssrc)
	{
		printf("Fatal Error - Could not open \"progs.src\" for output.\n");
		exit(1);
	}

	QCC_CatVFile(Decompileprogssrc, "./progs.dat\n\n");

	QCC_CatVFile(Decompileprogssrc, "#pragma flag enable lax //remove this line once you've fixed up any decompiler bugs...\n");
	if (origcopyright)
		QCC_CatVFile(Decompileprogssrc, "//#pragma copyright \"%s\"\n", origcopyright);
	QCC_CatVFile(Decompileprogssrc, "\n", origcopyright);


	for (i = 1; i < numfunctions; i++)
	{
		d = &functions[i];

		fname[0] = '\0';
		if (d->s_file <= strofs && d->s_file >= 0)
			sprintf(fname, "%s", strings + d->s_file);
		// FrikaC -- not sure if this is cool or what?
		bogusname = false;
		if (strlen(fname) <= 0)
			bogusname = true;
		else for (o = 0; o < strlen(fname); o++)
		{
			if ((fname[o] < 'a' || fname[o] > 'z') && 
			  (fname[o] < '0' || fname[o] > '9') &&
			  (fname[o] <'A' || fname[o] > 'Z') &&
			  (fname[o] != '.' && fname[o] != '!' && fname[o] != '_'))
			{
				if (fname[o] == '/')
					fname[o] = '.';
				else if (fname[o] == '\\')
					fname[o] = '.';
				else
				{
						bogusname = true;
						break;
				}
			}
		}

		if (bogusname)
		{
			if (*fname && !DecompileAlreadySeen(fname, NULL))
			{
				synth_name[0] = 0;
			}
			if(!TrySynthName(qcva("%s", strings + d->s_name)) && !synth_name[0])
				QC_snprintfz(synth_name, sizeof(synth_name), "frik%i.qc", fake_name++);

			QC_snprintfz(fname, sizeof(fname), synth_name);
		}
		else
			synth_name[0] = 0;



		if (!DecompileAlreadySeen(fname, &f))
		{
			printf("decompiling %s\n", fname);
			compilecb();
			QCC_CatVFile(Decompileprogssrc, "%s\n", fname);
		}
		if (!f)
		{
			printf("Fatal Error - Could not open \"%s\" for output.\n", fname);
			exit(1);
		}
		Decompileofile = f;
		DecompileFunction(strings + d->s_name, &lastglob);
	}
}

void DecompileProgsDat(char *name, void *buf, size_t bufsize)
{
	char *c = ReadProgsCopyright(buf, bufsize);
	if (c)
		printf("Copyright: %s\n", c);

	maxtypeinfos = 64;
	qcc_typeinfo = (void *)malloc(sizeof(QCC_type_t)*maxtypeinfos);
	numtypeinfos = 0;

	type_void = QCC_PR_NewType("void", ev_void, true);
	type_string = QCC_PR_NewType("string", ev_string, true);
	type_float = QCC_PR_NewType("float", ev_float, true);
	type_vector = QCC_PR_NewType("vector", ev_vector, true);
	type_entity = QCC_PR_NewType("entity", ev_entity, true);
	type_field = QCC_PR_NewType("__field", ev_field, false);
	type_function = QCC_PR_NewType("__function", ev_function, false);
	type_function->aux_type = type_void;
	type_pointer = QCC_PR_NewType("__pointer", ev_pointer, false);
	type_integer = QCC_PR_NewType("__integer", ev_integer, true);
	type_variant = QCC_PR_NewType("variant", ev_variant, true);
	type_variant = QCC_PR_NewType("__variant", ev_variant, true);

	DecompileReadData(name, buf, bufsize);
	DecompileDecompileFunctions(c);

	printf("Done.");
}

char *DecompileGlobalStringNoContents(gofs_t ofs)
{
	int i;
	QCC_ddef_t *def;
	static char line[128];

	line[0] = '0';
	QC_snprintfz(line, sizeof(line), "%i(??""?)", ofs);

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if (def->ofs == ofs)
		{
			line[0] = '0';
			QC_snprintfz(line, sizeof(line), "%i(%s)", def->ofs, strings + def->s_name);
			break;
		}
	}

	i = strlen(line);
	for (; i < 16; i++)
		strcat(line, " ");
	strcat(line, " ");

	return line;
}

char *DecompileGlobalString(gofs_t ofs)
{
	char *s;
	int i;
	QCC_ddef_t *def;
	static char line[128];

	line[0] = '0';
	QC_snprintfz(line, sizeof(line), "%i(??""?)", ofs);

	for (i = 0; i < numglobaldefs; i++)
	{
		def = &globals[i];

		if (def->ofs == ofs)
		{

			line[0] = '0';
			if (!strcmp(strings + def->s_name, "IMMEDIATE") || !strcmp(strings + def->s_name, ".imm"))
			{
				s = PR_ValueString((etype_t)(def->type), &pr_globals[ofs]);
				QC_snprintfz(line, sizeof(line), "%i(%s)", def->ofs, s);
			}
			else
				QC_snprintfz(line, sizeof(line), "%i(%s)", def->ofs, strings + def->s_name);
		}
	}

	i = strlen(line);
	for (; i < 16; i++)
		strcat(line, " ");
	strcat(line, " ");

	return line;
}

void DecompilePrintStatement(dstatement_t * s)
{
	int i;

	printf("%4i : %s ", (int)(s - statements), pr_opcodes[s->op].opname);
	i = strlen(pr_opcodes[s->op].opname);
	for (; i < 10; i++)
		printf(" ");

	if (s->op == OP_IF_I || s->op == OP_IFNOT_I || s->op == OP_IF_F || s->op == OP_IFNOT_F)
		printf("%sbranch %i", DecompileGlobalString(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", DecompileGlobalString(s->a));
		printf("%s", DecompileGlobalStringNoContents(s->b));
	}
	else
	{
		if (s->a)
			printf("%s", DecompileGlobalString(s->a));
		if (s->b)
			printf("%s", DecompileGlobalString(s->b));
		if (s->c)
			printf("%s", DecompileGlobalStringNoContents(s->c));
	}
	printf("\n");
}

void DecompilePrintFunction(char *name)
{
	int i;
	dstatement_t *ds;
	dfunction_t *df;

	for (i = 0; i < numfunctions; i++)
		if (!strcmp(name, strings + functions[i].s_name))
			break;
	if (i == numfunctions)
	{
		printf("Fatal Error: No function names \"%s\"\n", name);
		exit(1);
	}
	df = functions + i;

	printf("Statements for %s:\n", name);
	ds = statements + df->first_statement;
	while (1)
	{
		DecompilePrintStatement(ds);

		if (!ds->op)
			break;
		ds++;
	}
}