//=======================================================================
//			Copyright XashXT Group 2007 ©
//			qcc_utils.c - qcc common tools
//=======================================================================

#include "vprogs.h"
#include "const.h"

void Hash_InitTable(hashtable_t *table, int numbucks)
{
	table->numbuckets = numbucks;
	table->bucket = (bucket_t **)Qalloc(BytesForBuckets(numbucks));
}

uint Hash_Key(char *name, int modulus)
{
	//FIXME: optimize.
	uint	key;
	for (key = 0; *name; name++)
		key += ((key<<3) + (key>>28) + *name);
		
	return (key%modulus);
}

void *Hash_Get(hashtable_t *table, char *name)
{
	uint	bucknum = Hash_Key(name, table->numbuckets);
	bucket_t	*buck;

	buck = table->bucket[bucknum];
	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}

	return NULL;
}

void *Hash_GetKey(hashtable_t *table, int key)
{
	uint	bucknum = key%table->numbuckets;
	bucket_t	*buck;

	buck = table->bucket[bucknum];
	while(buck)
	{
		if ((int)buck->keystring == key)
			return buck->data;

		buck = buck->next;
	}

	return NULL;
}

void *Hash_GetNext(hashtable_t *table, char *name, void *old)
{
	uint	bucknum = Hash_Key(name, table->numbuckets);
	bucket_t	*buck;

	buck = table->bucket[bucknum];
	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
		{
			if (buck->data == old)//found the old one
				break;
		}
		buck = buck->next;
	}
	if (!buck) return NULL;

	buck = buck->next;//don't return old
	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_Add(hashtable_t *table, char *name, void *data, bucket_t *buck)
{
	uint	bucknum = Hash_Key(name, table->numbuckets);

	buck->data = data;
	buck->keystring = name;
	buck->next = table->bucket[bucknum];
	table->bucket[bucknum] = buck;

	return buck;
}

void *Hash_AddKey(hashtable_t *table, int key, void *data, bucket_t *buck)
{
	uint	bucknum = key%table->numbuckets;

	buck->data = data;
	buck->keystring = (char*)key;
	buck->next = table->bucket[bucknum];
	table->bucket[bucknum] = buck;

	return buck;
}

void Hash_Remove(hashtable_t *table, char *name)
{
	uint	bucknum = Hash_Key(name, table->numbuckets);
	bucket_t	*buck;	

	buck = table->bucket[bucknum];
	if (!STRCMP(name, buck->keystring))
	{
		table->bucket[bucknum] = buck->next;
		return;
	}

	while(buck->next)
	{
		if (!STRCMP(name, buck->next->keystring))
		{
			buck->next = buck->next->next;
			return;
		}

		buck = buck->next;
	}
}

void Hash_RemoveData(hashtable_t *table, char *name, void *data)
{
	uint	bucknum = Hash_Key(name, table->numbuckets);
	bucket_t	*buck;	

	buck = table->bucket[bucknum];
	if (buck->data == data)
	{
		if (!STRCMP(name, buck->keystring))
		{
			table->bucket[bucknum] = buck->next;
			return;
		}
	}
	while(buck->next)
	{
		if (buck->next->data == data)
		{
			if (!STRCMP(name, buck->next->keystring))
			{
				buck->next = buck->next->next;
				return;
			}
		}
		buck = buck->next;
	}
}


void Hash_RemoveKey(hashtable_t *table, int key)
{
	uint	bucknum = key%table->numbuckets;
	bucket_t	*buck;	

	buck = table->bucket[bucknum];
	if ((int)buck->keystring == key)
	{
		table->bucket[bucknum] = buck->next;
		return;
	}
	while(buck->next)
	{
		if ((int)buck->next->keystring == key)
		{
			buck->next = buck->next->next;
			return;
		}
		buck = buck->next;
	}
}

/*
================
PR_decode
================
*/
int PR_decode(int complen, int len, int method, char *src, char **dst)
{
	int	i;
	char	*buffer = *dst;

	switch(method)
	{
	case CMP_NONE:
		if (complen != len) 
		{
			MsgDev(D_WARN, "PR_decode: complen[%d] != len[%d]\n", complen, len);
			return false;
		}		
		Mem_Copy(buffer, src, len);
		break;
	case CMP_LZSS:
		if (complen != len) 
		{
			MsgDev(D_WARN, "PR_decode: complen[%d] != len[%d]\n", complen, len);
			return false;
		}
		for (i = 0; i < len; i++) buffer[i] = src[i] ^ 0xA5;
		break;
	case CMP_ZLIB:
		VFS_Unpack( src, complen, dst, len );
		break;
	default:
		MsgDev(D_WARN, "PR_decode: invalid method\n");
		return false;
	}	
	return true;
}

/*
================
PR_encode
================
*/
int PR_encode(int len, int method, char *src, file_t *h)
{
	int	i, pos;
	vfile_t	*vf;

	switch(method)
	{
	case CMP_NONE:
		FS_Write(h, src, len);
		return len;
	case CMP_LZSS:
		for (i = 0; i < len; i++) src[i] = src[i] ^ 0xA5;
		FS_Write(h, src, len);
		return len;
	case CMP_ZLIB:
		vf = VFS_Open( h, "wz" );
		pos = FS_Tell(h); // member ofs
		VFS_Write( vf, src, len );
		VFS_Close( vf );
		return FS_Tell(h) - pos;
	default:
		MsgDev(D_WARN, "PR_encode: invalid method\n");
		return false;
	}
}

// CopyString returns an offset from the string heap
int PR_CopyString (char *str, bool noduplicate )
{
	int	old;
	char	*s;

	if (noduplicate)
	{
		if (!str || !*str) return 0;
		for (s = strings; s < strings + strofs; s++)
			if (!com.strcmp(s, str)) return s - strings;
	}

	old = strofs;
	com.strcpy (strings + strofs, str);
	strofs += com.strlen(str)+1;
	return old;
}

/*
================
PR_WriteSourceFiles

include sources into progs.dat for fake decompile
if it needs
================
*/
bool PR_WriteSourceFiles( file_t *h, dprograms_t *progs, bool sourceaswell )
{
	dsource_t		*idf;
	cachedsourcefile_t	*f;
	int		num = 0;
	int		ofs;

	for (f = sourcefile, num = 0; f; f = f->next)
	{
		if (f->type == FT_CODE && !sourceaswell)
			continue;
		num++;
	}
	if( !num )
	{
		progs->ofssources = progs->numsources = 0;
		return false;
	}
	idf = Qalloc(sizeof(dsource_t) * num);
	for( f = sourcefile, num = 0; f; f = f->next )
	{
		if( f->type == FT_CODE && !sourceaswell )
			continue;
		com.strncpy( idf[num].name, f->filename, 64 );
		idf[num].size = f->size;
		idf[num].compression = CMP_ZLIB;
		idf[num].filepos = FS_Tell( h );
		idf[num].disksize = PR_encode(f->size, idf[num].compression, f->file, h );
		num++;
	}
	ofs = FS_Tell( h );	
	FS_Write( h, idf, sizeof(dsource_t) * num );
	sourcefile = NULL;

	// update header
	progs->ofssources = ofs;
	progs->numsources = num;
	return true;
}

int PR_WriteBodylessFuncs (file_t *handle)
{
	def_t		*d;
	int		ret = 0;

	for (d = pr.def_head.next; d; d = d->next)
	{
		// function parms are ok
		if (d->type->type == ev_function && !d->scope)
		{
			if (d->initialized != 1 && d->references > 0)
			{
				FS_Write(handle, d->name, com.strlen(d->name)+1);
				ret++;
			}
		}
	}
	return ret;
}

/*
====================
AddBuffer

copy string into buffer and process crc
====================
*/
#define NEED_CRC	1 // calcaulate crc
#define NEED_CPY	2 // copy string
#define NEED_ALL	NEED_CRC|NEED_CPY

#define ADD1(p) AddBuffer(p, &crc, file, NEED_ALL)
#define ADD2(p) AddBuffer(p, &crc, file, NEED_CPY)
#define ADD3(p) AddBuffer(p, &crc, file, NEED_CRC)

_inline void AddBuffer(char *p, word *crc, char *file, byte flags )
{
	char	*s;
	int	i = com.strlen(file);

	if (i + com.strlen(p) + 1 >= PROGDEFS_MAX_SIZE)
		return;

	for(s = p; *s; s++, i++)
	{
		if(flags & NEED_CRC) CRC_ProcessByte(crc, *s);
		if(flags & NEED_CPY) file[i] = *s;
	}
	if(flags & NEED_CPY) file[i] = '\0';
}

/*
====================
PR_WriteProgdefs

write advanced progdefs.h into disk
====================
*/
word PR_WriteProgdefs( void )
{
	char		file[PROGDEFS_MAX_SIZE];
	string		header_name, lwr_header;
	char		lwr_prefix[8], upr_prefix[8];
	char		array_size[8]; // g-cont: mega name!
	int		f = 0, k = 1;
	string		path;
	def_t		*d;
	word		crc;

	CRC_Init( &crc );
	Mem_Set( file, 0, PROGDEFS_MAX_SIZE );
	FS_FileBase( progsoutname, header_name );
	com.strupr( header_name, header_name ); // as part of define name
	com.strlwr( header_name, lwr_header ); // as part of head comment

	// convert progsoutname to prefix
	// using special case for "server", because "se" prefix looks ugly
	if(!com.stricmp( header_name, "server" )) com.strncpy( lwr_prefix, "sv", 8 );
	else com.strnlwr( header_name, lwr_prefix, 3 );
	com.strnupr( lwr_prefix, upr_prefix, 3 );

	ADD1("//=======================================================================\n");
	ADD1("//			Copyright XashXT Group 2008 ©\n");
	ADD2(va("//			%s_edict.h - %s prvm edict\n", lwr_prefix, lwr_header ));
	ADD1("//=======================================================================\n");
	ADD2(va("#ifndef %s_EDICT_H\n#define %s_EDICT_H\n", upr_prefix, upr_prefix ));
	ADD1("\nstruct");
	ADD2(va(" %s_globalvars_s", lwr_prefix ));
	ADD1(va("\n{"));	
	ADD2(va("\n"));
	ADD1(va("\tint\tpad[%i];\n", RESERVED_OFS));

	// write globalvars_t
	for( d = pr.def_head.next; d; d = d->next )
	{
		if( !com.strcmp (d->name, "end_sys_globals")) break;
		if( d->ofs < RESERVED_OFS ) continue;
		if( com.strchr( d->name, '[' )) continue; // skip arrays
		if( d->arraysize > 1 ) com.snprintf( array_size, 8, "[%i]", d->arraysize );
		else array_size[0] = '\0'; // clear array
			
		switch( d->type->type )
		{
		case ev_float:
			ADD1(va("\tfloat\t%s%s;\n",d->name, array_size));
			break;
		case ev_vector:
			ADD1(va("\tvec3_t\t%s%s;\n",d->name, array_size));
			d = d->next->next->next; // skip the elements
			break;
		case ev_string:
			ADD1(va("\tstring_t\t%s%s;\n",d->name, array_size));
			break;
		case ev_function:
			ADD1(va("\tfunc_t\t%s%s;\n",d->name, array_size));
			break;
		case ev_entity:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		case ev_integer:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		default:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		}
	}
	ADD1("};\n\n");

	// write entvars_t
	ADD1("struct");
	ADD2(va(" %s_entvars_s", lwr_prefix ));
	ADD1("\n{\n");

	// write entvars_t
	for( d = pr.def_head.next; d; d = d->next )
	{
		if( !com.strcmp (d->name, "end_sys_fields")) break;
		if( d->type->type != ev_field ) continue;
		if( com.strchr( d->name, '[' )) continue; // skip arrays
		if( d->arraysize > 1 ) com.snprintf( array_size, 8, "[%i]", d->arraysize );
		else array_size[0] = '\0'; // clear array

		switch( d->type->aux_type->type )
		{
		case ev_float:
			ADD1(va("\tfloat\t%s%s;\n",d->name, array_size ));
			break;
		case ev_vector:
			ADD1(va("\tvec3_t\t%s%s;\n",d->name, array_size));
			d = d->next->next->next; // skip the elements
			break;
		case ev_string:
			ADD1(va("\tstring_t\t%s%s;\n",d->name, array_size));
			break;
		case ev_function:
			ADD1(va("\tfunc_t\t%s%s;\n",d->name, array_size));
			break;
		case ev_entity:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		case ev_integer:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		default:
			ADD1(va("\tint\t%s%s;\n",d->name, array_size));
			break;
		}
	}
	ADD1("};\n\n");
	ADD2(va("#define PROG_CRC_%s\t\t%i\n", header_name, crc ));
	ADD2(va("\n#endif//%s_EDICT_H", upr_prefix ));

	if( ForcedCRC ) crc = ForcedCRC;	// potentially backdoor

	if( host_instance == HOST_NORMAL || host_instance == HOST_DEDICATED )
	{
		// make sure what progs file will be placed into right directory
		com.snprintf( progsoutname, MAX_SYSPATH, "%s/%s.dat", GI->vprogs_dir, header_name );
	}

	switch( crc )
	{
	case 8505:
		PR_Message("Xash3D unmodified server.dat\n");
		if(!com.strcmp(progsoutname, "unknown.dat")) com.strcpy(progsoutname, "server.dat");
		break;
	case 3720:
		PR_Message("Xash3D unmodified client.dat\n");
		if(!com.strcmp(progsoutname, "unknown.dat")) com.strcpy(progsoutname, "client.dat");
		break;		
	case 2158:
		PR_Message("Xash3D unmodified uimenu.dat\n");
		if(!com.strcmp(progsoutname, "unknown.dat")) com.strcpy(progsoutname, "uimenu.dat");
		break;
	default:
		PR_Message("Custom progs crc %d\n", crc );
		if(!com.strcmp(progsoutname, "unknown.dat")) com.strcpy(progsoutname, "progs.dat");
		if( host_instance != HOST_QCCLIB ) break;
		com.snprintf( path, MAX_STRING, "../%s_edict.h", lwr_prefix );
		PR_Message( "writing %s\n", path ); // auto-determine
		FS_WriteFile( path, file, com.strlen(file));
		break;
	}
	return crc;
}

void PR_WriteDAT( void )
{
	ddef_t		*dd;
	file_t		*f;
	dprograms_t	progs; // header
	char		element[MAX_NAME];
	int		i, crc, progsize, num_ref;
	def_t		*def, *comp_x, *comp_y, *comp_z;

	crc = PR_WriteProgdefs(); // write progdefs.h

	progs.flags = 0;

	if(numstatements > MAX_STATEMENTS) PR_ParseError(ERR_INTERNAL, "Too many statements - %i\n", numstatements );
	if(strofs > MAX_STRINGS) PR_ParseError(ERR_INTERNAL, "Too many strings - %i\n", strofs );

	PR_UnmarshalLocals();

	if(opt_compstrings) progs.flags |= COMP_STRINGS;
	if(opt_compfunctions)
	{
		progs.flags |= COMP_FUNCTIONS;
		progs.flags |= COMP_STATEMENTS;
	}
	if(opt_compress_other)
	{
		progs.flags |= COMP_DEFS;
		progs.flags |= COMP_FIELDS;
		progs.flags |= COMP_GLOBALS;
	}

	// compression of blocks?
	if( opt_writelinenums ) progs.flags |= COMP_LINENUMS;	
	if( opt_writetypes ) progs.flags |= COMP_TYPES;

	// part of how compilation works. This def is always present, and never used.
	def = PR_GetDef(NULL, "end_sys_globals", NULL, false, 0);
	if(def) def->references++;

	def = PR_GetDef(NULL, "end_sys_fields", NULL, false, 0);
	if(def) def->references++;

	for (def = pr.def_head.next; def; def = def->next)
	{
		if (def->type->type == ev_vector || (def->type->type == ev_field && def->type->aux_type->type == ev_vector))
		{	
			// do the references, so we don't get loadsa not referenced VEC_HULL_MINS_x
			com.sprintf(element, "%s_x", def->name);
			comp_x = PR_GetDef(NULL, element, def->scope, false, 0);
			com.sprintf(element, "%s_y", def->name);
			comp_y = PR_GetDef(NULL, element, def->scope, false, 0);
			com.sprintf(element, "%s_z", def->name);
			comp_z = PR_GetDef(NULL, element, def->scope, false, 0);

			num_ref = def->references;
			if (comp_x && comp_y && comp_z)
			{
				num_ref += comp_x->references;
				num_ref += comp_y->references;
				num_ref += comp_z->references;

				if (!def->references)
				{
					if (!comp_x->references || !comp_y->references || !comp_z->references)				
						num_ref = 0; // one of these vars is useless...
				}
				def->references = num_ref;

				if (!num_ref) num_ref = 1;
				if (comp_x) comp_x->references = num_ref;
				if (comp_y) comp_y->references = num_ref;
				if (comp_z) comp_z->references = num_ref;
			}
		}
		if (def->references <= 0)
		{
			if(def->local) PR_Warning(WARN_NOTREFERENCED, strings + def->s_file, def->s_line, "'%s' : unreferenced local variable", def->name);
			if (opt_unreferenced && def->type->type != ev_field) continue;
		}
		if (def->type->type == ev_function)
		{
			if( opt_function_names && functions[G_FUNCTION(def->ofs)].first_statement < 0 )
			{
				def->name = "";
			}
			if( !def->timescalled )
			{
				if( def->references <= 1 )
					PR_Warning(WARN_DEADCODE, strings + def->s_file, def->s_line, "%s is never directly called or referenced (spawn function or dead code)", def->name);
			}
			if( opt_stripfunctions && def->timescalled >= def->references - 1 )	
			{
				// make sure it's not copied into a different var.
				// if it ever does self.think then it could be needed for saves.
				// if it's only ever called explicitly, the engine doesn't need to know.
				continue;
			}
		}
		else if( def->type->type == ev_field )
		{
			dd = &fields[numfielddefs];
			dd->type = def->type->aux_type->type;
			dd->s_name = PR_CopyString( def->name, opt_noduplicatestrings );
			dd->ofs = G_INT(def->ofs);
			numfielddefs++;
		}
		else if ((def->scope||def->constant) && (def->type->type != ev_string || opt_constant_names_strings))
		{
			if (opt_constant_names) continue;
		}

		dd = &qcc_globals[numglobaldefs];
		numglobaldefs++;

		if (opt_writetypes) dd->type = def->type-qcc_typeinfo;
		else dd->type = def->type->type;

		if ( def->saved && ((!def->initialized || def->type->type == ev_function) && def->type->type != ev_field && def->scope == NULL))
			dd->type |= DEF_SAVEGLOBAL;

		if (def->shared) dd->type |= DEF_SHARED;

		if (opt_locals && (def->scope || !com.strcmp(def->name, "IMMEDIATE")))
		{
			dd->s_name = 0;
		}
		else dd->s_name = PR_CopyString (def->name, opt_noduplicatestrings );
		dd->ofs = def->ofs;
	}
	if(numglobaldefs > MAX_GLOBALS) PR_ParseError(ERR_INTERNAL, "Too many globals - %i\n", numglobaldefs );

	strofs = (strofs + 3) & ~3;

	PR_Message("Linking...\n");
	if( host_instance == HOST_QCCLIB )
	{
		// don't flood into engine console
		MsgDev(D_INFO, "%6i strofs (of %i)\n", strofs, MAX_STRINGS);
		MsgDev(D_INFO, "%6i numstatements (of %i)\n", numstatements, MAX_STATEMENTS);
		MsgDev(D_INFO, "%6i numfunctions (of %i)\n", numfunctions, MAX_FUNCTIONS);
		MsgDev(D_INFO, "%6i numglobaldefs (of %i)\n", numglobaldefs, MAX_GLOBALS);
		MsgDev(D_INFO, "%6i numfielddefs (%i unique) (of %i)\n", numfielddefs, pr.size_fields, MAX_FIELDS);
		MsgDev(D_INFO, "%6i numpr_globals (of %i)\n", numpr_globals, MAX_REGS);	
	}	

	f = FS_Open( progsoutname, "wb" );
	if( !f ) PR_ParseError( ERR_INTERNAL, "Couldn't open file %s", progsoutname );
	FS_Write(f, &progs, sizeof(progs));
	FS_Write(f, "\r\n\r\n", 4);
	FS_Write(f, v_copyright, com.strlen(v_copyright) + 1);
	FS_Write(f, "\r\n\r\n", 4);

	progs.ofs_strings = FS_Tell(f);
	progs.numstrings = strofs;

	PR_WriteBlock(f, progs.ofs_strings, strings, strofs, progs.flags & COMP_STRINGS);

	progs.ofs_statements = FS_Tell(f);
	progs.numstatements = numstatements;

	for (i = 0; i < numstatements; i++)
	{
		statements[i].op = LittleLong(statements[i].op);
		statements[i].a = LittleLong(statements[i].a);
		statements[i].b = LittleLong(statements[i].b);
		statements[i].c = LittleLong(statements[i].c);
	}
	PR_WriteBlock(f, progs.ofs_statements, statements, progs.numstatements*sizeof(dstatement_t), progs.flags & COMP_STATEMENTS);

	progs.ofs_functions = FS_Tell(f);
	progs.numfunctions = numfunctions;

	for (i = 0; i < numfunctions; i++)
	{
		functions[i].first_statement = LittleLong (functions[i].first_statement);
		functions[i].parm_start = LittleLong (functions[i].parm_start);
		functions[i].s_name = LittleLong (functions[i].s_name);
		functions[i].s_file = LittleLong (functions[i].s_file);
		functions[i].numparms = LittleLong ((functions[i].numparms > MAX_PARMS) ? MAX_PARMS : functions[i].numparms);
		functions[i].locals = LittleLong (functions[i].locals);
	}

	PR_WriteBlock(f, progs.ofs_functions, functions, progs.numfunctions*sizeof(dfunction_t), progs.flags & COMP_FUNCTIONS);

	progs.ofs_globaldefs = FS_Tell(f);
	progs.numglobaldefs = numglobaldefs;
	for (i = 0; i < numglobaldefs; i++)
	{
		qcc_globals[i].type = LittleLong(qcc_globals[i].type);
		qcc_globals[i].ofs = LittleLong(qcc_globals[i].ofs);
		qcc_globals[i].s_name = LittleLong(qcc_globals[i].s_name);
	}

	PR_WriteBlock(f, progs.ofs_globaldefs, qcc_globals, progs.numglobaldefs*sizeof(ddef_t), progs.flags & COMP_DEFS);

	progs.ofs_fielddefs = FS_Tell(f);
	progs.numfielddefs = numfielddefs;

	for (i = 0; i < numfielddefs; i++)
	{
		fields[i].type = LittleLong(fields[i].type);
		fields[i].ofs = LittleLong(fields[i].ofs);
		fields[i].s_name = LittleLong(fields[i].s_name);
	}

	PR_WriteBlock(f, progs.ofs_fielddefs, fields, progs.numfielddefs*sizeof(ddef_t), progs.flags & COMP_FIELDS);

	progs.ofs_globals = FS_Tell(f);
	progs.numglobals = numpr_globals;

	for (i = 0; (uint) i < numpr_globals; i++) ((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
	PR_WriteBlock(f, progs.ofs_globals, pr_globals, numpr_globals*4, progs.flags & COMP_GLOBALS);

	if(opt_writetypes)
	{
		for (i = 0; i < numtypeinfos; i++)
		{
			if (qcc_typeinfo[i].aux_type) qcc_typeinfo[i].aux_type = (type_t*)(qcc_typeinfo[i].aux_type - qcc_typeinfo);
			if (qcc_typeinfo[i].next) qcc_typeinfo[i].next = (type_t*)(qcc_typeinfo[i].next - qcc_typeinfo);
			qcc_typeinfo[i].name = (char *)PR_CopyString(qcc_typeinfo[i].name, true );
		}
	}

	progs.ident = VPROGSHEADER32;
	progs.version = VPROGS_VERSION;
	progs.ofssources = 0;
	progs.ofslinenums = 0;
	progs.ident = 0;
	progs.ofsbodylessfuncs = 0;
	progs.numbodylessfuncs = 0;
	progs.ofs_types = 0;
	progs.numtypes = 0;
	progs.ofsbodylessfuncs = FS_Tell(f);
	progs.numbodylessfuncs = PR_WriteBodylessFuncs(f);		

	if( opt_writelinenums )
	{
		progs.ofslinenums = FS_Tell(f);
		PR_WriteBlock(f, progs.ofslinenums, statement_linenums, numstatements*sizeof(int), progs.flags & COMP_LINENUMS);
	}

	if( opt_writetypes )
	{
		progs.ofs_types = FS_Tell(f);
		progs.numtypes = numtypeinfos;
		PR_WriteBlock(f, progs.ofs_types, qcc_typeinfo, progs.numtypes*sizeof(type_t), progs.flags & COMP_TYPES);
	}
	
	PR_WriteSourceFiles( f, &progs, opt_writesources );

	progsize = ((FS_Tell(f)+3) & ~3);
	progs.entityfields = pr.size_fields;
	progs.crc = crc;

	// byte swap the header and write it out
	for (i = 0; i < sizeof(progs)/4; i++)((int *)&progs)[i] = LittleLong (((int *)&progs)[i]);
	FS_Seek(f, 0, SEEK_SET);
	FS_Write(f, &progs, sizeof(progs));
	if( asmfile ) FS_Close(asmfile);

	if( host_instance == HOST_QCCLIB )
		MsgDev(D_INFO, "Writing %s, total size %i bytes\n", progsoutname, progsize );
	FS_Close( f );
}

/*
=======================
PR_UnmarshalLocals

marshalled locals remaps all the functions to use the range MAX_REGS 
onwards for the offset to thier locals.
this function remaps all the locals back into the function.
=======================
*/
void PR_UnmarshalLocals( void )
{
	def_t	*def;
	uint	ofs;
	uint	maxo;
	int	i;

	ofs = numpr_globals;
	maxo = ofs;

	for (def = pr.def_head.next ; def ; def = def->next)
	{
		if (def->ofs >= MAX_REGS)	//unmap defs.
		{
			def->ofs = def->ofs + ofs - MAX_REGS;
			if (maxo < def->ofs)
				maxo = def->ofs;
		}
	}

	for (i = 0; i < numfunctions; i++)
	{
		if (functions[i].parm_start == MAX_REGS)
			functions[i].parm_start = ofs;
	}

	PR_RemapOffsets(0, numstatements, MAX_REGS, MAX_REGS + maxo-numpr_globals + 3, ofs);

	numpr_globals = maxo+3;
	if (numpr_globals > MAX_REGS)
		PR_ParseError(ERR_INTERNAL, "Too many globals are in use to unmarshal all locals");

	if (maxo-ofs) PR_Message("Total of %i marshalled globals\n", maxo-ofs);
}

byte *PR_LoadFile( char *filename, bool crash, int type )
{
	int		length;
	cachedsourcefile_t	*newfile;
	string		fullname;
	byte		*file;
	char		*path;

	// NOTE: in-game we can't use ../pathes, but root directory always
	// ahead over ../pathes, so translate path from
	// ../common/svc_user.h to source/common/svc_user.h
	if( host_instance == HOST_NORMAL || host_instance == HOST_DEDICATED )
	{
		if((path = com.strstr( filename, ".." )))
		{
			path += 2; // skip ..
			com.snprintf( fullname, MAX_STRING, "%s%s", GI->source_dir, path );
		}
		else com.snprintf( fullname, MAX_STRING, "%s/%s/%s", GI->source_dir, sourcedir, filename );
	}
	else com.strncpy( fullname, filename, MAX_STRING );
 
	file = FS_LoadFile( fullname, &length );
	
	if( !file || !length ) 
	{
		if( crash ) PR_ParseError( ERR_INTERNAL, "Couldn't open file %s", fullname );
		else return NULL;
	}
	newfile = (cachedsourcefile_t*)Qalloc(sizeof(cachedsourcefile_t));
	newfile->next = sourcefile;
	sourcefile = newfile; // make chain
          
	com.strcpy(sourcefile->filename, fullname );
	sourcefile->file = file;
	sourcefile->type = type;
	sourcefile->size = length;

	return sourcefile->file;
}

bool PR_Include( char *filename )
{
	char		*newfile;
	char		fname[512];
	char		*opr_file_p;
	string_t		os_file, os_file2;
	int		opr_source_line;
	char		*ocompilingfile;
	includechunk_t	*oldcurrentchunk;

	ocompilingfile = compilingfile;
	os_file = s_file;
	os_file2 = s_file2;
	opr_source_line = pr_source_line;
	opr_file_p = pr_file_p;
	oldcurrentchunk = currentchunk;

	com.strcpy(fname, filename);
	newfile = QCC_LoadFile( fname, true );
	currentchunk = NULL;
	pr_file_p = newfile;
	PR_CompileFile( newfile, fname );
	currentchunk = oldcurrentchunk;

	compilingfile = ocompilingfile;
	s_file = os_file;
	s_file2 = os_file2;
	pr_source_line = opr_source_line;
	pr_file_p = opr_file_p;

	return true;
}

void PR_WriteBlock(file_t *f, fs_offset_t pos, const void *data, size_t blocksize, bool compress)
{
	vfile_t	*h;
	int	len = 0;

	if (compress)
	{		
		h = VFS_Open( f, "wz" );
		VFS_Write( h, data, blocksize );	// write into buffer
		FS_Write(f, &len, sizeof(int));	// first four bytes it's a compressed filesize
		f = VFS_Close(h);			// deflate, then write into disk
		len = LittleLong(FS_Tell(f) - pos);	// calculate complength
		FS_Seek(f, pos, SEEK_SET);		// seek back to start block...
		FS_Write(f, &len, sizeof(int));	// ... and write real complength value.
		FS_Seek(f, 0, SEEK_END);		// return
	}
	else FS_Write(f, data, blocksize);		// just write data
}

byte *PR_CreateProgsSRC( void )
{
	search_t		*qc = FS_Search( "*", true );
	const char	*datname = "unknown.dat\n";	// outname will be set by PR_WriteProgdefs
	byte		*newprogs_src = NULL;
	char		searchmask[8][16];
	string		headers[2];		// contains filename with struct description
	bool		have_entvars = 0;
	bool		have_globals = 0;
	int		i, k, j = 0;

	// hardcoded table! don't change!
	com.strcpy( searchmask[0], "qh" );	// quakec header
	com.strcpy( searchmask[1], "h" );	// c-style header
	com.strcpy( searchmask[2], "qc" );	// quakec sources
	com.strcpy( searchmask[3], "c" );	// c-style sources

	if(!qc)
	{
		PR_ParseError(ERR_INTERNAL, "Couldn't open file progs.src" );
		return NULL;
	}
	Mem_Set( headers, '/0', MAX_STRING * 2 );

	for( i = 0; i < qc->numfilenames; i++ )
	{
		// search by mask		
		for( k = 0; k < 8; k++)
		{
			// skip blank mask
			if(!com.strlen( searchmask[k] )) continue;
			if(!com.stricmp( searchmask[k], FS_FileExtension( qc->filenames[i] ))) // validate ext
			{
				script_t	*source = Com_OpenScript( qc->filenames[i], NULL, 0 );
				token_t	token;

				if( source )
				{
					while( Com_ReadToken( source, SC_ALLOW_NEWLINES, &token ))
					{
						// parse all sources for "end_sys_globals"
						if( !com.strcmp( token.string, "end_sys_globals" ))
						{
							com.strncpy( headers[0], qc->filenames[i], MAX_STRING );
							have_globals = true;
						}
						else if( !com.strcmp( token.string, "end_sys_fields" ))
						{
							com.strncpy( headers[1], qc->filenames[i], MAX_STRING );
							have_entvars = true;
						}
						if( have_globals && have_entvars )
						{
							Com_CloseScript( source );
							goto buildnewlist; // end of parsing
						}
					}
					Com_CloseScript( source );
				}
			}	
		}
	}

	// globals and locals not declared
	PR_ParseError( ERR_INTERNAL, "Couldn't open file progs.src" );
	return NULL;
buildnewlist:

	newprogs_src = Qrealloc( newprogs_src, j + com.strlen( datname ) + 1 ); // outfile name
	Mem_Copy( newprogs_src + j, (char *)datname, com.strlen( datname ));
	j += com.strlen(datname) + 1; // null term

	// file contains "sys_globals" and possible "sys_fields"
	newprogs_src = Qrealloc(newprogs_src, j + com.strlen(headers[0]) + 2); // first file
	com.strncat(newprogs_src, va("%s\n", headers[0]), com.strlen(headers[0]) + 1);
	j += com.strlen(headers[0]) + 2; //null term

	if(STRCMP( headers[0], headers[1] ))
	{
		// file contains sys_fields description
		newprogs_src = Qrealloc( newprogs_src, j + com.strlen( headers[1] ) + 2 ); // second file (option)
		com.strncat( newprogs_src, va("%s\n", headers[1]), com.strlen(headers[1]) + 1);
		j += com.strlen(headers[1]) + 2; //null term
	}

	// add headers
	for( i = 0; i < qc->numfilenames; i++ )
	{
		for( k = 0; k < 2; k++)
		{
			// skip blank mask
			if(!com.strlen(searchmask[k])) continue;
			if(!com.stricmp(searchmask[k], FS_FileExtension(qc->filenames[i]))) // validate ext
			{
				if(!com.strcmp(qc->filenames[i], headers[0]) || !com.strcmp(qc->filenames[i], headers[1]))
					break; //we already have it, just skip
				newprogs_src = Qrealloc( newprogs_src, j + com.strlen(qc->filenames[i]) + 2);
				com.strncat(newprogs_src, va("%s\n", qc->filenames[i]), com.strlen(qc->filenames[i]) + 1);
				j += com.strlen(qc->filenames[i]) + 2;
			}
		}
	}
	
	// add other sources
	for(i = 0; i < qc->numfilenames; i++)
	{
		for( k = 2; k < 8; k++)
		{
			// skip blank mask
			if(!com.strlen(searchmask[k])) continue;
			if(!com.stricmp(searchmask[k], FS_FileExtension(qc->filenames[i]))) // validate ext
			{
				if(!com.strcmp(qc->filenames[i], headers[0]) || !com.strcmp(qc->filenames[i], headers[1]))
					break; //we already have it, just skip
				newprogs_src = Qrealloc( newprogs_src, j + com.strlen(qc->filenames[i]) + 2);
				com.strncat(newprogs_src, va("%s\n", qc->filenames[i]), com.strlen(qc->filenames[i]) + 1);
				j += com.strlen(qc->filenames[i]) + 2;
			}
		}
	}
	Mem_Free( qc ); // free search
	FS_WriteFile( "progs.src", newprogs_src, j );

	return newprogs_src;
}