// Copyright (C) 2007 Id Software, Inc.
//

#include "../precompiled.h"
#pragma hdrstop

#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "Script_Program.h"
#include "Script_Compiler.h"
#include "Script_Thread.h"
#include "Script_Helper.h"
#include "Script_ScriptObject.h"

#include "../../framework/Licensee.h"

const int SCRIPT_TYPE_PTR_SIZE = sizeof( int );

// simple types.  function types are dynamically allocated
idTypeDef	type_void( ev_void, &def_void, "void", 0, NULL );
idTypeDef	type_scriptevent( ev_scriptevent, &def_scriptevent, "scriptevent", SCRIPT_TYPE_PTR_SIZE, NULL );
idTypeDef	type_namespace( ev_namespace, &def_namespace, "namespace", SCRIPT_TYPE_PTR_SIZE, NULL );
idTypeDef	type_string( ev_string, &def_string, "string", MAX_STRING_LEN, NULL );
idTypeDef	type_wstring( ev_wstring, &def_wstring, "wstring", MAX_STRING_LEN * sizeof( wchar_t ), NULL );
idTypeDef	type_float( ev_float, &def_float, "float", sizeof( float ), NULL );
idTypeDef	type_vector( ev_vector, &def_vector, "vector", sizeof( idVec3 ), NULL );
idTypeDef	type_field( ev_field, &def_field, "field", SCRIPT_TYPE_PTR_SIZE, NULL );
idTypeDef	type_function( ev_function, &def_function, "function", sizeof( void * ), &type_void );
idTypeDef	type_virtualfunction( ev_virtualfunction, &def_virtualfunction, "virtual function", sizeof( int ), NULL );
idTypeDef	type_pointer( ev_pointer, &def_pointer, "pointer", sizeof( void * ), NULL );

idTypeDef	type_object( ev_object, &def_object, "object", SCRIPT_TYPE_PTR_SIZE, NULL );

idTypeDef	type_jumpoffset( ev_jumpoffset, &def_jumpoffset, "<jump>", sizeof( int ), NULL );		// only used for jump opcodes
idTypeDef	type_argsize( ev_argsize, &def_argsize, "<argsize>", sizeof( int ), NULL );				// only used for function call and thread opcodes
idTypeDef	type_boolean( ev_boolean, &def_boolean, "boolean", sizeof( int ), NULL );
idTypeDef	type_internalscriptevent( ev_internalscriptevent, &def_internalscriptevent, "virtual", SCRIPT_TYPE_PTR_SIZE/*sizeof( void * )*/, NULL );

idVarDef	def_void( &type_void );
idVarDef	def_scriptevent( &type_scriptevent );
idVarDef	def_namespace( &type_namespace );
idVarDef	def_string( &type_string );
idVarDef	def_wstring( &type_wstring );
idVarDef	def_float( &type_float );
idVarDef	def_vector( &type_vector );
idVarDef	def_field( &type_field );
idVarDef	def_function( &type_function );
idVarDef	def_virtualfunction( &type_virtualfunction );
idVarDef	def_pointer( &type_pointer );
idVarDef	def_object( &type_object );
idVarDef	def_jumpoffset( &type_jumpoffset );		// only used for jump opcodes
idVarDef	def_argsize( &type_argsize );
idVarDef	def_boolean( &type_boolean );
idVarDef	def_internalscriptevent( &type_internalscriptevent );

/***********************************************************************

  function_t

***********************************************************************/

/*
================
function_t::function_t
================
*/
function_t::function_t() {
	Clear();
}

/*
================
function_t::Allocated
================
*/
size_t function_t::Allocated( void ) const {
	return name.Allocated() + parmSize.Allocated();
}

/*
================
function_t::SetName
================
*/
void function_t::SetName( const char *name ) {
	this->name = name;
}

/*
================
function_t::Name
================
*/
const char *function_t::Name( void ) const {
	return name;
}

/*
================
function_t::Clear
================
*/
void function_t::Clear( void ) {
	eventdef		= NULL;
	def				= NULL;
	type			= NULL;
	firstStatement	= 0;
	numStatements	= 0;
	parmTotal		= 0;
	locals			= 0;
	filenum			= 0;
	name.Clear();
	parmSize.Clear();
	virtualIndex	= -1;
}

/***********************************************************************

  idTypeDef

***********************************************************************/

/*
================
idTypeDef::idTypeDef
================
*/
idTypeDef::idTypeDef( void ) {
	program = NULL;
	parmTypes.SetGranularity( 1 );
	parmNames.SetGranularity( 1 );
	functions.SetGranularity( 1 );
	globalVirtuals.SetGranularity( 1 );
}

/*
================
idTypeDef::idTypeDef
================
*/
idTypeDef::idTypeDef( const idTypeDef &other ) {
	program = NULL;

	*this = other;
}

/*
================
idTypeDef::idTypeDef
================
*/
idTypeDef::idTypeDef( etype_t etype, idVarDef *edef, const char *ename, int esize, idTypeDef *aux ) {
	name		= ename;
	type		= etype;
	def			= edef;
	size		= esize;
	auxType		= aux;
	program		= NULL;
	
	parmTypes.SetGranularity( 1 );
	parmNames.SetGranularity( 1 );
	functions.SetGranularity( 1 );
	globalVirtuals.SetGranularity( 1 );
}

/*
================
idTypeDef::~idTypeDef
================
*/
idTypeDef::~idTypeDef( void ) {
	if ( program != NULL ) {
		program->RemoveFromHash( this );
	}
}

/*
================
idTypeDef::Init
================
*/
void idTypeDef::Init( etype_t etype, idVarDef *edef, const char *ename, int esize, idTypeDef *aux ) {
	name		= ename;
	type		= etype;
	def			= edef;
	size		= esize;
	auxType		= aux;
}

/*
================
idTypeDef::operator=
================
*/
void idTypeDef::operator=( const idTypeDef& other ) {
	if ( program != NULL ) {
		SetName( NULL, "" );
	}

	type			= other.type;
	def				= other.def;
	size			= other.size;
	auxType			= other.auxType;
	parmTypes		= other.parmTypes;
	parmNames		= other.parmNames;
	functions		= other.functions;
	globalVirtuals	= other.globalVirtuals;

	SetName( other.program, other.name );
}

/*
================
idTypeDef::Allocated
================
*/
size_t idTypeDef::Allocated( void ) const {
	size_t memsize;
	int i;

	memsize = name.Allocated() + parmTypes.Allocated() + parmNames.Allocated() + functions.Allocated();
	for( i = 0; i < parmTypes.Num(); i++ ) {
		memsize += parmNames[ i ].Allocated();
	}

	return memsize;
}

/*
================
idTypeDef::Inherits

Returns true if basetype is an ancestor of this type.
================
*/
bool idTypeDef::Inherits( const idTypeDef *basetype ) const {
	idTypeDef *superType;

	if ( type != ev_object ) {
		return false;
	}

	if ( this == basetype ) {
		return true;
	}
	for( superType = auxType; superType != NULL; superType = superType->auxType ) {
		if ( superType == basetype ) {
			return true;
		}
	}

	return false;
}

/*
================
idTypeDef::MatchesType

Returns true if both types' base types and parameters match
================
*/
bool idTypeDef::MatchesType( const idTypeDef &matchtype ) const {
	int i;

	if ( this == &matchtype ) {
		return true;
	}

	if ( ( type != matchtype.type ) || ( auxType != matchtype.auxType ) ) {
		return false;
	}

	if ( parmTypes.Num() != matchtype.parmTypes.Num() ) {
		return false;
	}

	for( i = 0; i < matchtype.parmTypes.Num(); i++ ) {
		if ( parmTypes[ i ] != matchtype.parmTypes[ i ] ) {
			return false;
		}
	}

	return true;
}

/*
================
idTypeDef::MatchesVirtualFunction

Returns true if both functions' base types and parameters match
================
*/
bool idTypeDef::MatchesVirtualFunction( const idTypeDef &matchfunc ) const {
	int i;

	if ( this == &matchfunc ) {
		return true;
	}

	if ( ( type != matchfunc.type ) || ( auxType != matchfunc.auxType ) ) {
		return false;
	}

	if ( parmTypes.Num() != matchfunc.parmTypes.Num() ) {
		return false;
	}

	if ( parmTypes.Num() > 0 ) {
		if ( !parmTypes[ 0 ]->Inherits( matchfunc.parmTypes[ 0 ] ) ) {
			return false;
		}
	}

	for( i = 1; i < matchfunc.parmTypes.Num(); i++ ) {
		if ( parmTypes[ i ] != matchfunc.parmTypes[ i ] ) {
			return false;
		}
	}

	return true;
}

/*
================
idTypeDef::AddFunctionParm

Adds a new parameter for a function type.
================
*/
void idTypeDef::AddFunctionParm( idTypeDef *parmtype, const char *name ) {
	if ( type != ev_function ) {
		throw idCompileError( "idTypeDef::AddFunctionParm : tried to add parameter on non-function type" );
	}

	parmTypes.Append( parmtype );
	idStr &parmName = parmNames.Alloc();
	parmName = name;
}

/*
================
idTypeDef::AddField

Adds a new field to an object type.
================
*/
void idTypeDef::AddField( idTypeDef *fieldtype, const char *name ) {
	if ( type != ev_object ) {
		throw idCompileError( "idTypeDef::AddField : tried to add field to non-object type" );
	}

	parmTypes.Append( fieldtype );
	idStr &parmName = parmNames.Alloc();
	parmName = name;

	if ( fieldtype->FieldType()->Inherits( &type_object ) ) {
		size += type_object.Size();
	} else {
		size += fieldtype->FieldType()->Size();
	}
}

/*
================
idTypeDef::SetName
================
*/
void idTypeDef::SetName( idProgram* _program, const char* newname ) {
	bool wasInHash = false;
	if ( program != NULL ) {
		wasInHash = program->RemoveFromHash( this );
	}

	name = newname;

	if ( wasInHash ) {
		if ( _program != NULL ) {
			_program->AddToHash( this );
		}
	}
}

/*
================
idTypeDef::Name
================
*/
const char *idTypeDef::Name( void ) const {
	return name;
}

/*
================
idTypeDef::Type
================
*/
etype_t idTypeDef::Type( void ) const {
	return type;
}

/*
================
idTypeDef::Size
================
*/
int idTypeDef::Size( void ) const {
	return size;
}

/*
================
idTypeDef::SuperClass

If type is an object, then returns the object's superclass
================
*/
idTypeDef *idTypeDef::SuperClass( void ) const {
	if ( type != ev_object ) {
		throw idCompileError( "idTypeDef::SuperClass : tried to get superclass of a non-object type" );
	}

	return auxType;
}

/*
================
idTypeDef::ReturnType

If type is a function, then returns the function's return type
================
*/
idTypeDef *idTypeDef::ReturnType( void ) const {
	if ( type != ev_function ) {
		throw idCompileError( "idTypeDef::ReturnType: tried to get return type on non-function type" );
	}

	return auxType;
}

/*
================
idTypeDef::SetReturnType

If type is a function, then sets the function's return type
================
*/
void idTypeDef::SetReturnType( idTypeDef *returntype ) {
	if ( type != ev_function ) {
		throw idCompileError( "idTypeDef::SetReturnType: tried to set return type on non-function type" );
	}

	auxType = returntype;
}

/*
================
idTypeDef::FieldType

If type is a field, then returns it's type
================
*/
idTypeDef *idTypeDef::FieldType( void ) const {
	if ( type != ev_field ) {
		throw idCompileError( "idTypeDef::FieldType: tried to get field type on non-field type" );
	}

	return auxType;
}

/*
================
idTypeDef::SetFieldType

If type is a field, then sets the function's return type
================
*/
void idTypeDef::SetFieldType( idTypeDef *fieldtype ) {
	if ( type != ev_field ) {
		throw idCompileError( "idTypeDef::SetFieldType: tried to set return type on non-function type" );
	}

	auxType = fieldtype;
}

/*
================
idTypeDef::PointerType

If type is a pointer, then returns the type it points to
================
*/
idTypeDef *idTypeDef::PointerType( void ) const {
	if ( type != ev_pointer ) {
		throw idCompileError( "idTypeDef::PointerType: tried to get pointer type on non-pointer" );
	}

	return auxType;
}

/*
================
idTypeDef::SetPointerType

If type is a pointer, then sets the pointer's type
================
*/
void idTypeDef::SetPointerType( idTypeDef *pointertype ) {
	if ( type != ev_pointer ) {
		throw idCompileError( "idTypeDef::SetPointerType: tried to set type on non-pointer" );
	}

	auxType = pointertype;
}

/*
================
idTypeDef::NumParameters
================
*/
int idTypeDef::NumParameters( void ) const {
	return parmTypes.Num();
}

/*
================
idTypeDef::GetParmType
================
*/
idTypeDef *idTypeDef::GetParmType( int parmNumber ) const {
	assert( parmNumber >= 0 );
	assert( parmNumber < parmTypes.Num() );
	return parmTypes[ parmNumber ];
}

/*
================
idTypeDef::GetParmName
================
*/
const char *idTypeDef::GetParmName( int parmNumber ) const {
	assert( parmNumber >= 0 );
	assert( parmNumber < parmTypes.Num() );
	return parmNames[ parmNumber ];
}

/*
================
idTypeDef::NumFunctions
================
*/
int idTypeDef::NumFunctions( void ) const {
	return functions.Num();
}

/*
================
idTypeDef::GetFunctionNumber
================
*/
int idTypeDef::GetFunctionNumber( const function_t *func ) const {
	int i;

	for( i = 0; i < functions.Num(); i++ ) {
		if ( functions[ i ] == func ) {
			return i;
		}
	}
	return -1;
}

/*
================
idTypeDef::GetFunction
================
*/
const function_t *idTypeDef::GetFunction( int funcNumber ) const {
	assert( funcNumber >= 0 );
	assert( funcNumber < functions.Num() );
	return functions[ funcNumber ];
}

/*
================
idTypeDef::GetVirtualFunction
================
*/
const function_t *idTypeDef::GetVirtualFunction( int funcNumber ) const {
	int index = globalVirtuals.GetFirst( funcNumber );
	if ( index == -1 ) {
		return NULL;
	}
	return GetFunction( index );
}

/*
================
idTypeDef::AddFunction
================
*/
void idTypeDef::AddFunction( const function_t* func, idProgram& program ) {
	int i;

	for( i = 0; i < functions.Num(); i++ ) {
		if ( !idStr::Cmp( functions[ i ]->def->Name(), func->def->Name() ) ) {
			if ( func->def->TypeDef()->MatchesVirtualFunction( *functions[ i ]->def->TypeDef() ) ) {
				functions[ i ] = func;
				return;
			}
		}
	}
	
	int index = functions.Append( func );

	int globalVirtualIndex = program.MatchesVirtualFunction( *func->def->TypeDef() );
	if ( globalVirtualIndex != -1 ) {
		globalVirtuals.Add( globalVirtualIndex, index );
	}
}

/***********************************************************************

  idVarDef

***********************************************************************/

/*
================
idVarDef::idVarDef()
================
*/
idVarDef::idVarDef( idTypeDef *typeptr ) {
	typeDef		= typeptr;
	scope		= NULL;
	numUsers	= 0;
	settings.initialized	= idVarDef::uninitialized;
	settings.isReturn		= false;
	memset( &value, 0, sizeof( value ) );
	name		= NULL;
	next		= NULL;
}

/*
============
idVarDef::~idVarDef
============
*/
idVarDef::~idVarDef() {
	if ( name ) {
		name->RemoveDef( this );
	}
}

/*
================
idVarDef::Init
================
*/
void idVarDef::Init( idTypeDef *typeptr ) {
	typeDef		= typeptr;
	scope		= NULL;
	numUsers	= 0;
	settings.initialized	= idVarDef::uninitialized;
	settings.isReturn		= false;
	memset( &value, 0, sizeof( value ) );
	name		= NULL;
	next		= NULL;
}

/*
================
idVarDef::Clear
================
*/
void idVarDef::Clear() {
	if ( name ) {
		name->RemoveDef( this );
	}
}

/*
============
idVarDef::Name
============
*/
const char *idVarDef::Name( void ) const {
	return name->Name();
}

/*
============
idVarDef::GlobalName
============
*/
const char *idVarDef::GlobalName( void ) const {
	if ( scope != &def_namespace ) {
		return va( "%s::%s", scope->GlobalName(), name->Name() );
	} else {
		return name->Name();
	}
}

/*
============
idVarDef::DepthOfScope
============
*/
int idVarDef::DepthOfScope( const idVarDef *otherScope ) const {
	const idVarDef *def;
	int depth;

	depth = 1;
	for( def = otherScope; def != NULL; def = def->scope ) {
		if ( def == scope ) {
			return depth;
		}
		depth++;
	}

	return 0;
}

/*
============
idVarDef::SetFunction
============
*/
void idVarDef::SetFunction( function_t *func ) {
	assert( typeDef );
	settings.initialized	= initializedConstant;
	settings.isReturn		= false;
	assert( typeDef->Type() == ev_function );
	value.functionPtr = func;
}

/*
============
idVarDef::SetObject
============
*/
void idVarDef::SetObject( idScriptObject* object ) {
	assert( typeDef );
	settings.initialized	= initializedVariable;
	settings.isReturn		= false;
	assert( typeDef->Inherits( &type_object ) );
	*value.objectId = object ? object->GetHandle() : 0;
}

/*
============
idVarDef::SetValue
============
*/
void idVarDef::SetValue( const eval_t &_value, bool constant ) {
	assert( typeDef );
	if ( constant ) {
		settings.initialized = initializedConstant;
	} else {
		settings.initialized = initializedVariable;
	}
	settings.isReturn = false;

	switch( typeDef->Type() ) {
	case ev_pointer :
	case ev_boolean :
	case ev_field :
		*value.intPtr = _value._int;
		break;

	case ev_jumpoffset :
		value.jumpOffset = _value._int;
		break;

	case ev_argsize :
		value.argSize = _value._int;
		break;

	case ev_object :
		*value.objectId = _value._objectId;
		break;

	case ev_string :
		idStr::Copynz( value.stringPtr, _value.stringPtr, MAX_STRING_LEN );
		break;

	case ev_wstring :
		idWStr::Copynz( value.wstringPtr, _value.wstringPtr, MAX_STRING_LEN );
		break;

	case ev_float :
		*value.floatPtr = _value._float;
		break;

	case ev_vector :
		value.vectorPtr->x = _value.vector[ 0 ];
		value.vectorPtr->y = _value.vector[ 1 ];
		value.vectorPtr->z = _value.vector[ 2 ];
		break;

	case ev_function :
		value.functionPtr = _value.function;
		break;

	case ev_virtualfunction :
		value.virtualFunction = _value._int;
		break;

	default :
		throw idCompileError( va( "weird type on '%s'", Name() ) );
		break;
	}
}

/*
============
idVarDef::SetString
============
*/
void idVarDef::SetString( const char *string, bool constant ) {
	if ( constant ) {
		settings.initialized = initializedConstant;
	} else {
		settings.initialized = initializedVariable;
	}
	settings.isReturn = false;
	
	assert( typeDef && ( typeDef->Type() == ev_string ) );
	idStr::Copynz( value.stringPtr, string, MAX_STRING_LEN );
}

/*
============
idVarDef::PrintInfo
============
*/
void idVarDef::PrintInfo( const idProgram& program, idFile *file, int instructionPointer ) const {
	const statement_t	*jumpst;
	int			jumpto;
	etype_t		etype;
	int			i;
	int			len;
	const char	*ch;

	if ( settings.initialized == initializedConstant ) {
		file->Printf( "const " );
	}

	etype = typeDef->Type();
	switch( etype ) {
	case ev_jumpoffset :
		jumpto = instructionPointer + value.jumpOffset;
		jumpst = &program.GetStatement( jumpto );
		file->Printf( "address %d [%s(%d)]", jumpto, program.GetFilename( jumpst->file ), jumpst->linenumber );
		break;

	case ev_function :
		if ( value.functionPtr->eventdef ) {
			file->Printf( "event %s", GlobalName() );
		} else {
			file->Printf( "function %s", GlobalName() );
		}
		break;

	case ev_field :
		file->Printf( "field %d", value.ptrOffset );
		break;

	case ev_argsize:
		file->Printf( "args %d", value.argSize );
		break;

	default:
		file->Printf( "%s ", typeDef->Name() );
		if ( settings.initialized == initializedConstant ) {
			switch( etype ) {
			case ev_string :
				file->Printf( "\"" );
				len = idStr::Length( value.stringPtr );
				ch = value.stringPtr;
				for( i = 0; i < len; i++, ch++ ) {
					if ( idStr::CharIsPrintable( *ch ) ) {
						file->Printf( "%c", *ch );
					} else if ( *ch == '\n' ) {
						file->Printf( "\\n" );
					} else {
						file->Printf( "\\x%.2x", static_cast<int>( *ch ) );
					}
				}
				file->Printf( "\"" );
				break;

			case ev_wstring :
				assert( false );/*
				file->Printf( "\"" );
				len = idStr::Length( value.stringPtr );
				ch = value.stringPtr;
				for( i = 0; i < len; i++, ch++ ) {
					if ( idStr::CharIsPrintable( *ch ) ) {
						file->Printf( "%c", *ch );
					} else if ( *ch == '\n' ) {
						file->Printf( "\\n" );
					} else {
						file->Printf( "\\x%.2x", static_cast<int>( *ch ) );
					}
				}
				file->Printf( "\"" );*/
				break;

			case ev_vector :
				file->Printf( "'%s'", value.vectorPtr->ToString() );
				break;

			case ev_float :
                file->Printf( "%f", *value.floatPtr );
				break;

			case ev_virtualfunction :
				file->Printf( "vtable[ %d ]", value.virtualFunction );
				break;

			default :
				file->Printf( "%d", *value.intPtr );
				break;
			}
		} else if ( settings.initialized == stackVariable ) {
			file->Printf( "stack[%d]", value.stackOffset );
		} else {
			file->Printf( "global[%d]", program.GetVarDefIndex( this ) );
		}
		break;
	}
}

/***********************************************************************

  idVarDef

***********************************************************************/

/*
============
idVarDefName::AddDef
============
*/
void idVarDefName::AddDef( idVarDef *def ) {
	assert( def->Next() == NULL );
	def->SetName( this );
	def->SetNext( defs );
	defs = def;
}

/*
============
idVarDefName::RemoveDef
============
*/
void idVarDefName::RemoveDef( idVarDef *def ) {
	if ( defs == def ) {
		defs = def->Next();
	} else {
		for ( idVarDef* d = defs; d->Next() != NULL; d = d->Next() ) {
			if ( d->Next() == def ) {
				d->SetNext( def->Next() );
				break;
			}
		}
	}
	def->SetNext( NULL );
	def->SetName( NULL );
}

/***********************************************************************

  idProgram

***********************************************************************/

/*
============
idProgram::AllocType
============
*/
idTypeDef *idProgram::AllocType( idTypeDef &type ) {
	idTypeDef* newtype = typeDefAllocator.Alloc();
	*newtype = type;
	
	int index = types.Append( newtype );

	AddToHash( newtype, index );

	return newtype;
}

/*
============
idProgram::AllocType
============
*/
idTypeDef *idProgram::AllocType( etype_t etype, idVarDef *edef, const char *ename, int esize, idTypeDef *aux ) {
	idTypeDef *newtype;

	newtype	= typeDefAllocator.Alloc();
	newtype->Init( etype, edef, ename, esize, aux );
	int index = types.Append( newtype );

	AddToHash( newtype, index );

	return newtype;
}

/*
============
idProgram::RemoveFromHash
============
*/
bool idProgram::RemoveFromHash( idTypeDef* type ) {
	int key = typeHash.GenerateKey( type->Name() );

	for ( int index = typeHash.GetFirst( key ); index != typeHash.NULL_INDEX; index = typeHash.GetNext( index ) ) {
		if ( types[ index ] != type ) {
			continue;
		}

		typeHash.Remove( key, index );
		return true;
	}

	return false;
}

/*
============
idProgram::AddToHash
============
*/
void idProgram::AddToHash( idTypeDef* type, int index ) {
	if ( index == -1 ) {
		for ( int i = 0; i < types.Num(); i++ ) {
			if ( types[ i ] != type ) {
				continue;
			}

			index = i;
			break;
		}
	}

	if ( index != -1 ) {
		type->SetProgram( this );
		int key = typeHash.GenerateKey( type->Name() );
		typeHash.Add( key, index );
	}
}

/*
============
idProgram::GetType

Returns a preexisting complex type that matches the parm, or allocates
a new one and copies it out.
============
*/
idTypeDef *idProgram::GetType( idTypeDef &type, bool allocate ) {

//	for( int index = types.Num() - 1; index >= 0; index-- ) {

	int key = typeHash.GenerateKey( type.Name() );
	for ( int index = typeHash.GetFirst( key ); index != typeHash.NULL_INDEX; index = typeHash.GetNext( index ) ) {

		if ( types[ index ]->MatchesType( type ) && !idStr::Cmp( types[ index ]->Name(), type.Name() ) ) {
			return types[ index ];
		}
	}

	if ( !allocate ) {
		return NULL;
	}

	// allocate a new one
	return AllocType( type );
}

/*
============
idProgram::FindType

Returns a preexisting complex type that matches the name, or returns NULL if not found
============
*/
idTypeDef *idProgram::FindType( const char *name ) {
	idTypeDef	*check;
	int			i;

	for( i = types.Num() - 1; i >= 0; i-- ) {
		check = types[ i ];
		if ( !idStr::Cmp( check->Name(), name ) ) {
			return check;
		}
	}

	return NULL;
}

/*
============
idProgram::GetDefList
============
*/
idVarDef *idProgram::GetDefList( const char *name ) const {
	int i, hash;

	hash = varDefNameHash.GenerateKey( name, true );
	for ( i = varDefNameHash.GetFirst( hash ); i != -1; i = varDefNameHash.GetNext( i ) ) {
		if ( idStr::Cmp( varDefNames[i]->Name(), name ) == 0 ) {
			return varDefNames[i]->GetDefs();
		}
	}
	return NULL;
}

/*
============
idProgram::AddDefToNameList
============
*/
void idProgram::AddDefToNameList( idVarDef *def, const char *name ) {
	int i, hash;

	hash = varDefNameHash.GenerateKey( name, true );
	for ( i = varDefNameHash.GetFirst( hash ); i != -1; i = varDefNameHash.GetNext( i ) ) {
		if ( idStr::Cmp( varDefNames[i]->Name(), name ) == 0 ) {
			break;
		}
	}
	if ( i == -1 ) {
		idVarDefName* varDefName = varDefNameAllocator.Alloc();
		varDefName->Init( name );
		i = varDefNames.Append( varDefName );
		varDefNameHash.Add( hash, i );
	}
	varDefNames[i]->AddDef( def );
}

/*
============
idProgram::AllocDef
============
*/
idVarDef *idProgram::AllocDef( idTypeDef *type, const char *name, idVarDef *scope ) {
	idVarDef	*def;
	idStr		element;
	idVarDef	*def_x;
	idVarDef	*def_y;
	idVarDef	*def_z;

	// allocate a new def
	def = varDefAllocator.Alloc();
	def->Init( type );
	def->scope		= scope;
	def->numUsers	= 1;
	varDefs.Alloc() = def;

	// add the def to the list with defs with this name and set the name pointer
	AddDefToNameList( def, name );

	if ( ( type->Type() == ev_vector ) || ( ( type->Type() == ev_field ) && ( type->FieldType()->Type() == ev_vector ) ) ) {
		//
		// vector
		//
		if ( !idStr::Cmp( name, RESULT_STRING ) ) {
			// <RESULT> vector defs don't need the _x, _y and _z components
			assert( scope->Type() == ev_function );
			def->value.stackOffset	= scope->value.functionPtr->locals;
			def->settings.initialized		= idVarDef::stackVariable;
			scope->value.functionPtr->locals += type->Size();
		} else if ( scope->TypeDef()->Inherits( &type_object ) ) {
			idTypeDef	newtype( ev_field, NULL, "float field", 0, &type_float );
			idTypeDef	*type = GetType( newtype, true );

			// set the value to the variable's position in the object
			def->value.ptrOffset = scope->TypeDef()->Size();

			// make automatic defs for the vectors elements
			// origin can be accessed as origin_x, origin_y, and origin_z
			sprintf( element, "%s_x", def->Name() );
			def_x = AllocDef( type, element, scope );

			sprintf( element, "%s_y", def->Name() );
			def_y = AllocDef( type, element, scope );
			def_y->value.ptrOffset = def_x->value.ptrOffset + type_float.Size();

			sprintf( element, "%s_z", def->Name() );
			def_z = AllocDef( type, element, scope );
			def_z->value.ptrOffset = def_y->value.ptrOffset + type_float.Size();
		} else {
			// make automatic defs for the vectors elements
			// origin can be accessed as origin_x, origin_y, and origin_z
			sprintf( element, "%s_x", def->Name() );
			def_x = AllocDef( &type_float, element, scope );

			sprintf( element, "%s_y", def->Name() );
			def_y = AllocDef( &type_float, element, scope );

			sprintf( element, "%s_z", def->Name() );
			def_z = AllocDef( &type_float, element, scope );

			// point the vector def to the x coordinate
			def->value					= def_x->value;
			def->settings.initialized	= def_x->settings.initialized;
			def->settings.isReturn		= def_x->settings.isReturn;
		}
	} else if ( scope->TypeDef()->Inherits( &type_object ) ) {
		//
		// object variable
		//
		// set the value to the variable's position in the object
		def->value.ptrOffset = scope->TypeDef()->Size();
	} else if ( scope->Type() == ev_function ) {
		//
		// stack variable
		//
		// since we don't know how many local variables there are,
		// we have to have them go backwards on the stack
		def->value.stackOffset			= scope->value.functionPtr->locals;
		def->settings.initialized		= idVarDef::stackVariable;

		if ( type->Inherits( &type_object ) ) {
			// objects only have their entity number on the stack, not the entire object
			scope->value.functionPtr->locals += type_object.Size();
		} else {
			scope->value.functionPtr->locals += type->Size();
		}
	} else {
		//
		// global variable
		//

		int size;
		if ( def->TypeDef()->Inherits( &type_object ) ) {
			size = type_object.Size();
		} else {
			size = def->TypeDef()->Size();
		}
		def->value.bytePtr = &variables[ numVariables ];
		numVariables += size;
		if ( numVariables > sizeof( variables ) ) {
			throw idCompileError( va( "Exceeded global memory size (%d bytes)", sizeof( variables ) ) );
		}

		memset( def->value.bytePtr, 0, size );
	}

	return def;
}

/*
============
idProgram::GetDef

If type is NULL, it will match any type
============
*/
idVarDef *idProgram::GetDef( const idTypeDef *type, const char *name, const idVarDef *scope ) const {
	idVarDef		*def;
	idVarDef		*bestDef;
	int				bestDepth;
	int				depth;

	bestDepth = 0;
	bestDef = NULL;
	for( def = GetDefList( name ); def != NULL; def = def->Next() ) {
		if ( type && ( def->Type() == ev_function ) ) {
			if ( def->value.functionPtr->virtualIndex != -1 ) {
				continue;
			}
		}

		if ( def->scope->Type() == ev_namespace ) {
			depth = def->DepthOfScope( scope );
			if ( !depth ) {
				// not in the same namespace
				continue;
			}
		} else if ( def->scope != scope ) {
			// in a different function
			continue;
		} else {
			depth = 1;
		}

		if ( !bestDef || ( depth < bestDepth ) ) {
			bestDepth = depth;
			bestDef = def;
		}
	}

	// see if the name is already in use for another type
	if ( bestDef && type && ( bestDef->TypeDef() != type ) ) {
		throw idCompileError( va( "Type mismatch on redeclaration of %s", name ) );
	}

	return bestDef;
}

/*
============
idProgram::FreeDef
============
*/
void idProgram::FreeDef( idVarDef *def, const idVarDef *scope ) {
	if ( def->Type() == ev_vector ) {
		idVarDef* e;

		e = GetDef( NULL, va( "%s_x", def->Name() ), scope );
		if ( e ) {
			FreeDef( e, scope );
		}

		e = GetDef( NULL, va( "%s_y", def->Name() ), scope );
		if ( e ) {
			FreeDef( e, scope );
		}

		e = GetDef( NULL, va( "%s_z", def->Name() ), scope );
		if ( e ) {
			FreeDef( e, scope );
		}
	}

	if ( def->settings.isReturn ) {
		GetScopeReturn( def->scope ).returns.RemoveFast( def );
	}

	varDefs.Remove( def );

	def->Clear();
	varDefAllocator.Free( def );
}

#ifdef SCRIPT_EVENT_RETURN_CHECKS
/*
============
idProgram::GetExpectedReturn
============
*/
int idProgram::GetExpectedReturn( void ) {
	idThread* thread = idThread::CurrentThread();
	assert( thread != NULL );
	return thread->GetInterpreter().GetExpectedReturn();
}
#endif // SCRIPT_EVENT_RETURN_CHECKS

/*
============
idProgram::GetScopeReturn
============
*/
scopeReturn_t& idProgram::GetScopeReturn( idVarDef* scope ) {
	int key = scopeReturnsHash.GenerateKey( scope );
	
	for ( int index = scopeReturnsHash.GetFirst( key ); index != idHashIndex::NULL_INDEX; index = scopeReturnsHash.GetNext( index ) ) {
		if ( scopeReturns[ index ].scope != scope ) {
			continue;
		}

		return scopeReturns[ index ];
	}

	scopeReturnsHash.Add( key, scopeReturns.Num() );

	scopeReturn_t& r = scopeReturns.Alloc();
	r.scope = scope;
	return r;
}

/*
============
idProgram::FindFreeResultDef
============
*/
idVarDef *idProgram::FindFreeResultDef( idTypeDef *type, idVarDef *scope, const idVarDef *a, const idVarDef *b ) {
	scopeReturn_t& r = GetScopeReturn( scope );

	for ( int i = 0; i < r.returns.Num(); i++ ) {
		idVarDef* def = r.returns[ i ];

		if ( def == a || def == b ) {
			continue;
		}
		if ( def->TypeDef() != type ) {
			continue;
		}
		if ( def->numUsers <= 1 ) {
			continue;
		}
		return def;
	}

	idVarDef* newResultDef = AllocDef( type, RESULT_STRING, scope );
	newResultDef->settings.isReturn = true;

	r.returns.Alloc() = newResultDef;
	return newResultDef;
}

/*
================
idProgram::FindEvent

Searches for the specified script event function in the currently loaded script.

Returns 0 if function not found.
Returns >0 if function found.
================
*/
function_t *idProgram::FindEvent( const char *name ) {
	idVarDef	*def;

	assert( name );

	def = GetDef( NULL, name, &def_namespace );
	if ( !def ) {
		// couldn't find function
		return NULL;
	}

	if ( ( def->Type() == ev_function ) && ( def->value.functionPtr->eventdef != NULL ) ) {
		return def->value.functionPtr;
	}

	// is not a function, or is not an eventdef
	return NULL;
}

/*
================
idProgram::FindFunction

Searches for the specified function in the currently loaded script.  A full namespace should be
specified if not in the global namespace.

Returns 0 if function not found.
Returns >0 if function found.
================
*/
function_t* idProgram::FindFunctionInternal( const char *name ) const {
	int			start;
	int			pos;
	idVarDef	*namespaceDef;
	idVarDef	*def;

	assert( name );

	idStr fullname = name;
	start = 0;
	namespaceDef = &def_namespace;
	do {
		pos = fullname.Find( "::", true, start );
		if ( pos < 0 ) {
			break;
		}

		idStr namespaceName = fullname.Mid( start, pos - start );
		def = GetDef( NULL, namespaceName, namespaceDef );
		if ( !def ) {
			// couldn't find namespace
			return NULL;
		}
		namespaceDef = def;

		// skip past the ::
		start = pos + 2;
	} while( def->Type() == ev_namespace );

	idStr funcName = fullname.Right( fullname.Length() - start );
	def = GetDef( NULL, funcName, namespaceDef );
	if ( !def ) {
		// couldn't find function
		return NULL;
	}

	if ( ( def->Type() == ev_function ) && ( def->value.functionPtr->eventdef == NULL ) ) {
		return def->value.functionPtr;
	}

	// is not a function, or is an eventdef
	return NULL;
}

/*
================
idProgram::FindFunction

Searches for the specified object function in the currently loaded script.

Returns 0 if function not found.
Returns >0 if function found.
================
*/
function_t* idProgram::FindFunctionInternal( const char *name, const idTypeDef *type ) const {
	const idVarDef	*tdef;
	const idVarDef	*def;

	// look for the function
	def = NULL;
	for( tdef = type->def; tdef != &def_object; tdef = tdef->TypeDef()->SuperClass()->def ) {
		def = GetDef( NULL, name, tdef );
		if ( def ) {
			if ( def->Type() == ev_function ) {
				return def->value.functionPtr;
			} else {
				return NULL;
			}
		}
	}

	return NULL;
}

/*
================
idProgram::FindFunction

Searches for the specified object function in the currently loaded script only on the specified type.
================
*/
function_t* idProgram::FindFunctionLocal( const char *name, const idTypeDef *type ) const {
	// look for the function
	const idVarDef* def = GetDef( NULL, name, type->def );
	if ( def ) {
		if ( def->Type() == ev_function ) {
			return def->value.functionPtr;
		} else {
			return NULL;
		}
	}

	return NULL;
}

/*
================
idProgram::MatchesVirtualFunction
================
*/
int idProgram::MatchesVirtualFunction( const idTypeDef& match ) const {
	int i;

	for ( i = 0; i < globalVirtualFunctions.Num(); i++ ) {
		const function_t* function = globalVirtualFunctions[ i ];
		
		const idTypeDef& other = *function->def->TypeDef();

		if ( idStr::Cmp( match.Name(), other.Name() ) ) {
			continue;
		}

		if ( ( other.Type() != match.Type() ) || ( other.ReturnType() != match.ReturnType() ) ) {
			continue;
		}

		if ( ( other.NumParameters() + 1 ) != match.NumParameters() ) {
			continue;
		}

		int j;
		for( j = 1; j < match.NumParameters(); j++ ) {
			if ( other.GetParmType( j - 1 ) != match.GetParmType( j ) ) {
				continue;
			}
		}

		return i;
	}

	return -1;
}

/*
================
idProgram::AllocVirtualFunction
================
*/
function_t &idProgram::AllocVirtualFunction( idVarDef *def ) {
	if ( functions.Num() >= functions.Max() ) {
		throw idCompileError( va( "Exceeded maximum allowed number of functions (%d)", functions.Max() ) );
	}

	// fill in the dfunction
	function_t &func	= *functions.Alloc();
	func.eventdef		= NULL;
	func.def			= def;
	func.type			= def->TypeDef();
	func.firstStatement	= 0;
	func.numStatements	= 0;
	func.parmTotal		= 0;
	func.locals			= 0;
	func.filenum		= filenum;
	func.parmSize.SetGranularity( 1 );
	func.SetName( def->GlobalName() );
	func.virtualIndex	= globalVirtualFunctions.Append( &func );

	def->SetFunction( &func );

	return func;
}

/*
================
idProgram::AllocFunction
================
*/
function_t &idProgram::AllocFunction( idVarDef *def ) {
	if ( functions.Num() >= functions.Max() ) {
		throw idCompileError( va( "Exceeded maximum allowed number of functions (%d)", functions.Max() ) );
	}

	if ( ( functions.Num() % 20 ) == 0 ) {
		common->PacifierUpdate();
	}

	// fill in the dfunction
	function_t &func	= *functions.Alloc();
	func.eventdef		= NULL;
	func.def			= def;
	func.type			= def->TypeDef();
	func.firstStatement	= 0;
	func.numStatements	= 0;
	func.parmTotal		= 0;
	func.locals			= 0;
	func.filenum		= filenum;
	func.parmSize.SetGranularity( 1 );
	func.SetName( def->GlobalName() );
	func.virtualIndex	= -1;

	def->SetFunction( &func );

	return func;
}

/*
================
idProgram::AllocStatement
================
*/
statement_t *idProgram::AllocStatement( void ) {
	if ( statements.Num() >= statements.Max() ) {
		throw idCompileError( va( "Exceeded maximum allowed number of statements (%d)", statements.Max() ) );
	}
	return statements.Alloc();
}

#ifdef DEBUG_SCRIPTS
/*
==============
idProgram::DumpStats
==============
*/
void idProgram::DumpStats( void ) {
	idFile* dumpFile = fileSystem->OpenFileWrite( "scriptdump.txt" );
	if ( !dumpFile ) {
		gameLocal.Warning( "Failed to open dump file" );
		return;
	}

	idStr lastFile;

	for ( int j = 0; j < functions.Num(); j++ ) {
		if ( functions[ j ].eventdef != NULL ) {
			continue;
		}

		statement_t& firstStatement = statements[ functions[ j ].firstStatement ];
		if ( firstStatement.executionCount != 0 ) {
			continue;
		}

		const char* newFile = GetFilename( firstStatement.file );
		if ( lastFile.Cmp( newFile ) != 0 ) {
			lastFile = newFile;

			dumpFile->Printf( "\r\n======= File: %s =======\r\n", lastFile.c_str() );
		}

		dumpFile->Printf( "===== Function: %s =====\r\n", functions[ j ].Name() );

/*		for ( int k = 0; k < functions[ j ].numStatements; k++ ) {
			int i = functions[ j ].firstStatement + k;

			statement_t& s = statements[ i ];
			if ( s.executionCount != 0 ) {
				continue;
			}

			dumpFile->Printf( "line: %d \"%s\"\r\n", s.linenumber, idCompiler::opcodes[ s.op ].opname );
		}

		dumpFile->Printf( "\r\n" );*/
	}

	fileSystem->CloseFile( dumpFile );
}
#endif // DEBUG_SCRIPTS

/*
==============
idProgram::BeginCompilation

called before compiling a batch of files, clears the pr struct
==============
*/
void idProgram::BeginCompilation( void ) {
	statement_t	*statement;

	FreeData();

	types.SetGranularity( 2048 );
	varDefs.SetGranularity( 4096 );
	varDefNames.SetGranularity( 2048 );
	scopeReturns.SetGranularity( 128 );
	scopeReturnsHash.SetGranularity( 128 );

	scopeReturns.Clear(); // if we had an error, these wont be clean yet
	scopeReturnsHash.Clear();

	try {
		// make the first statement a return for a "NULL" function
		statement = AllocStatement();
		statement->linenumber	= 0;
		statement->file 		= 0;
		statement->op			= OP_RETURN;
		statement->a			= NULL;
		statement->b			= NULL;
		statement->c			= NULL;
#ifdef DEBUG_SCRIPTS
		statement->executionCount = 0;
#endif // DEBUG_SCRIPTS

		// define NULL
		//AllocDef( &type_void, "<NULL>", &def_namespace );

		// define the return def
		returnDef = AllocDef( &type_vector, "<RETURN>", &def_namespace );

		// define the return def for strings
		returnStringDef = AllocDef( &type_string, "<RETURN>", &def_namespace );

		// define the sys object
		sysDef = AllocDef( &type_void, "sys", &def_namespace );
	}

	catch( idCompileError &err ) {
		gameLocal.Error( "%s", err.error );
	}
}

/*
==============
idProgram::DisassembleStatement
==============
*/
void idProgram::DisassembleStatement( idFile *file, int instructionPointer ) const {
	opcode_t			*op;
	const statement_t	*statement;

	statement = &statements[ instructionPointer ];
	op = &idCompiler::opcodes[ statement->op ];
	file->Printf( "%20s(%d):\t%6d: %15s\t", fileList[ statement->file ].c_str(), statement->linenumber, instructionPointer, op->opname );

	if ( statement->a ) {
		file->Printf( "\ta: " );
		statement->a->PrintInfo( *this, file, instructionPointer );
	}

	if ( statement->b ) {
		file->Printf( "\tb: " );
		statement->b->PrintInfo( *this, file, instructionPointer );
	}

	if ( statement->c ) {
		file->Printf( "\tc: " );
		statement->c->PrintInfo( *this, file, instructionPointer );
	}

	file->Printf( "\n" );
}

/*
==============
idProgram::Disassemble
==============
*/
void idProgram::Disassemble( void ) const {
	int					i;
	int					instructionPointer;
	const function_t	*func;
	idFile				*file;

	file = fileSystem->OpenFileByMode( "script/disasm.txt", FS_WRITE );

	for( i = 0; i < functions.Num(); i++ ) {
		func = &functions[ i ];
		if ( func->eventdef ) {
			// skip eventdefs
			continue;
		}

		file->Printf( "\nfunction %s() %d stack used, %d parms, %d locals {\n", func->Name(), func->locals, func->parmTotal, func->locals - func->parmTotal );

		for( instructionPointer = 0; instructionPointer < func->numStatements; instructionPointer++ ) {
			DisassembleStatement( file, func->firstStatement + instructionPointer );
		}
	
		file->Printf( "}\n" );
	}

	fileSystem->CloseFile( file );
}

/*
==============
idProgram::FinishCompilation

Called after all files are compiled to check for errors
==============
*/
void idProgram::FinishCompilation( void ) {
	compiled = true;

	types.Condense();
	varDefs.Condense();
	varDefNames.Condense();

	variableDefaults.Clear();
	variableDefaults.SetNum( numVariables );

	for( int i = 0; i < numVariables; i++ ) {
		variableDefaults[ i ] = variables[ i ];
	}

	scopeReturns.Clear();
	scopeReturnsHash.Clear();
}

/*
==============
idProgram::CompileStats

called after all files are compiled to report memory usage.
==============
*/
void idProgram::CompileStats( void ) {
	size_t	memused;
	size_t	memallocated;
	int	numdefs;
	size_t	stringspace;
	size_t funcMem;
	int	i;

	gameLocal.DPrintf( "---------- Compile stats ----------\n" );
	gameLocal.DPrintf( "Files loaded:\n" );

	stringspace = 0;
	for ( i = 0; i < fileList.Num(); i++ ) {
		gameLocal.DPrintf( "   %s\n", fileList[ i ].c_str() );
		stringspace += fileList[ i ].Allocated();
	}
	stringspace += fileList.Size();

	numdefs = varDefs.Num();
	memused = varDefAllocator.GetTotalCount() * sizeof( idVarDef );//varDefs.Num() * sizeof( idVarDef );
	memused = varDefNameAllocator.GetTotalCount() * sizeof( idVarDefName );//varDefs.Num() * sizeof( idVarDef );
	memused += typeDefAllocator.GetTotalCount() * sizeof( idTypeDef );//types.Num() * sizeof( idTypeDef );
	memused += stringspace;

	for ( i = 0; i < types.Num(); i++ ) {
		memused += types[ i ]->Allocated();
	}

	funcMem = functions.MemoryUsed();
	for ( i = 0; i < functions.Num(); i++ ) {
		funcMem += functions[ i ].Allocated();
	}

	memallocated = funcMem + memused + sizeof( idProgram );

	memused += statements.MemoryUsed();
	memused += functions.MemoryUsed();	// name and filename of functions are shared, so no need to include them
	memused += sizeof( variables );

	gameLocal.DPrintf( "\nMemory usage:\n" );
	gameLocal.DPrintf( "     Strings: %d, %d bytes\n", fileList.Num(), stringspace );
	gameLocal.DPrintf( "  Statements: %d, %d bytes\n", statements.Num(), statements.MemoryUsed() );
	gameLocal.DPrintf( "   Functions: %d, %d bytes\n", functions.Num(), funcMem );
	gameLocal.DPrintf( "   Variables: %d bytes\n", numVariables );
	gameLocal.DPrintf( "    Mem used: %d bytes\n", memused );
	gameLocal.DPrintf( " Static data: %d bytes\n", sizeof( idProgram ) );
	gameLocal.DPrintf( "   Allocated: %d bytes\n", memallocated );
	gameLocal.DPrintf( " Thread size: %d bytes\n\n", sizeof( idThread ) );
}

idCVar g_showCompileStats( "g_showCompileStats", "0", CVAR_BOOL | CVAR_GAME, "sets whether to show stats at the end of compilation or not" );

/*
================
idProgram::CompileText
================
*/
bool idProgram::CompileText( const char *source, const char *text ) {
	idCompiler	compiler( this );
	int			i;
	idVarDef	*def;

	filenum = GetFilenum( source );

	try {
		compiler.CompileFile( text, filename );

		// check to make sure all functions prototyped have code
		for( i = 0; i < varDefs.Num(); i++ ) {
			def = varDefs[ i ];
			if ( ( def->Type() == ev_function ) && ( ( def->scope->Type() == ev_namespace ) || def->scope->TypeDef()->Inherits( &type_object ) ) ) {
				if ( ( def->value.functionPtr->virtualIndex == -1 ) && ( !def->value.functionPtr->eventdef && !def->value.functionPtr->firstStatement ) ) {
					throw idCompileError( va( "function %s was not defined", def->GlobalName() ) );
				}
			}
		}
	}
	
	catch( idCompileError &err ) {
		gameLocal.Error( "%s", err.error );
	};

	defaultType = FindType( "default" );

	if ( g_showCompileStats.GetBool() ) {
		CompileStats();
	}

	return true;
}

/*
================
idProgram::CompileFile
================
*/
void idProgram::CompileFile( const char* filename ) {
	char *src;
	bool result;

	if ( fileSystem->ReadFile( filename, ( void ** )&src, NULL ) < 0 ) {
		gameLocal.Error( "Couldn't load %s", filename );
	}

	result = CompileText( filename, src );

	fileSystem->FreeFile( src );

	if ( g_disasm.GetBool() ) {
		Disassemble();
	}

	if ( !result ) {
		gameLocal.Error( "Compile failed in file %s.", filename );
	}
}

/*
================
idProgram::GetFunctionIndex
================
*/
int idProgram::GetFunctionIndex( const function_t* function ) const {
	for ( int i = 0; i < functions.Num(); i++ ) {
		if ( &functions[ i ] == function ) {
			return i;
		}
	}
	return -1;
}

/*
================
idProgram::GetTypeDefIndex
================
*/
int idProgram::GetTypeDefIndex( const idTypeDef* typeDef ) const {
	for ( int i = 0; i < types.Num(); i++ ) {
		if ( types[ i ] == typeDef ) {
			return i;
		}
	}
	return -1;
}

/*
================
idProgram::GetVarDefIndex
================
*/
int idProgram::GetVarDefIndex( const idVarDef* varDef ) const {
	for ( int i = 0; i < varDefs.Num(); i++ ) {
		if ( varDefs[ i ] == varDef ) {
			return i;
		}
	}
	return -1;
}

/*
================
idProgram::FreeData
================
*/
void idProgram::FreeData( void ) {
	// free the defs
	varDefs.Clear();
	varDefNames.Clear();
	varDefNameHash.Free();
	varDefAllocator.Shutdown();
	varDefNameAllocator.Shutdown();

	returnDef		= NULL;
	returnStringDef = NULL;
	sysDef			= NULL;

	// free any special types we've created
	types.Clear();
	typeHash.Free();
	typeDefAllocator.Shutdown();

	filenum = 0;

	numVariables = 0;
	memset( variables, 0, sizeof( variables ) );

	// clear all the strings in the functions so that it doesn't look like we're leaking memory.
	for( int i = 0; i < functions.Num(); i++ ) {
		functions[ i ].Clear();
	}

	FreeScriptObjects();

	idThread::Restart();

	filename.Clear();
	fileList.Clear();
	statements.Clear();
	globalVirtualFunctions.Clear();
	functions.Clear();

	filename = "";

	compiled = false;

	scriptExporter.Clear( false );

	for ( int i = 0; i < MAX_SCRIPT_STACK_SIZE_COUNT; i++ ) {
		freeStacks[ i ].DeleteContents( true );
	}
}

/*
================
idProgram::Startup
================
*/
void idProgram::Startup( const char* defaultScript ) {
	compiled = false;

	gameLocal.Printf( "Initializing scripts\n" );

	idThread::Restart();

	BeginCompilation();

	CompileFile( defaultScript );

	if ( exporting ) {
		scriptExporter.Finish();
	}

	FinishCompilation();

	exporting = false;
}


/*
================
idProgram::CalculateChecksum
================
*/
int idProgram::CalculateChecksum( void ) const {
	int i, result;

	typedef struct {
		unsigned short	op;
		int				a;
		int				b;
		int				c;
		unsigned short	linenumber;
		unsigned short	file;
	} statementBlock_t;

	statementBlock_t	*statementList = new statementBlock_t[ statements.Num() ];

	memset( statementList, 0, ( sizeof(statementBlock_t) * statements.Num() ) );

	// Copy info into new list, using the variable numbers instead of a pointer to the variable
	for( i = 0; i < statements.Num(); i++ ) {
		statementList[i].op = statements[i].op;

		if ( statements[ i ].a ) {
			statementList[ i ].a = GetVarDefIndex( statements[ i ].a );
		} else {
			statementList[ i ].a = -1;
		}
		if ( statements[ i ].b ) {
			statementList[ i ].b = GetVarDefIndex( statements[ i ].b );
		} else {
			statementList[ i ].b = -1;
		}
		if ( statements[ i ].c ) {
			statementList[ i ].c = GetVarDefIndex( statements[ i ].c );
		} else {
			statementList[ i ].c = -1;
		}

		statementList[i].linenumber = statements[i].linenumber;
		statementList[i].file = statements[i].file;
	}

	result = MD4_BlockChecksum( statementList, ( sizeof(statementBlock_t) * statements.Num() ) );

	delete [] statementList;

	return result;
}

/*
==============
idProgram::Restart

Restores all variables to their initial value
==============
*/
void idProgram::Restart( void ) {
	idThread::Restart();

	for( int i = 0; i < types.Num(); i++ ) {
		typeDefAllocator.Free( types[ i ] );
	}
	types.SetNum( 0, false );
	typeHash.Clear();

	for( int i = 0; i < varDefs.Num(); i++ ) {
		varDefs[ i ]->Clear();
		varDefAllocator.Free( varDefs[ i ] );
	}
	varDefs.SetNum( 0, false );

	for( int i = 0; i < functions.Num(); i++ ) {
		functions[ i ].Clear();
	}
	functions.SetNum( 0	);

	statements.SetNum( 0 );
	fileList.SetNum( 0, false );
	filename.Clear();
	
	// reset the variables to their default values
	numVariables = variableDefaults.Num();
	for( int  i = 0; i < numVariables; i++ ) {
		variables[ i ] = variableDefaults[ i ];
	}
}

/*
================
idProgram::GetFilenum
================
*/
int idProgram::GetFilenum( const char *name ) {
	if ( filename == name ) {
		return filenum;
	}

	filenum = fileList.AddUnique( name );
	filename = name;

	return filenum;
}

/*
================
idProgram::idProgram
================
*/
idProgram::idProgram() {
	compiled = false;
	exporting = false;

	scriptExporter.SetProgram( this );
}

/*
================
idProgram::~idProgram
================
*/
idProgram::~idProgram() {
	FreeData();
}

/*
================
idProgram::ReturnEntity
================
*/
void idProgram::ReturnEntityInternal( idEntity* ent ) {
#ifdef SCRIPT_EVENT_RETURN_CHECKS
	if ( GetExpectedReturn() != D_EVENT_ENTITY && GetExpectedReturn() != D_EVENT_ENTITY_NULL ) {
		OnEventCallReturnFailure();
	}
#endif // SCRIPT_EVENT_RETURN_CHECKS
	ReturnObjectInternal( ent ? ent->GetScriptObject() : NULL );
}

/*
================
idProgram::ReturnObject
================
*/
void idProgram::ReturnObjectInternal( idScriptObject* object ) {
#ifdef SCRIPT_EVENT_RETURN_CHECKS
	if ( GetExpectedReturn() != D_EVENT_ENTITY && GetExpectedReturn() != D_EVENT_ENTITY_NULL && GetExpectedReturn() != D_EVENT_OBJECT ) {
		OnEventCallReturnFailure();
	}
#endif // SCRIPT_EVENT_RETURN_CHECKS
	*returnDef->value.objectId = object ? object->GetHandle() : 0;
}

/*
================
idProgram::Init
================
*/
bool idProgram::Init( void ) {
	Startup( SCRIPT_DEFAULT );
	return true;
}

/*
================
idProgram::Shutdown
================
*/
void idProgram::Shutdown( void ) {
	FreeData();
}

/*
================
idProgram::CreateThread
================
*/
sdProgramThread* idProgram::CreateThread( void ) {
	idThread* thread = idThread::AllocThread();
	return thread;
}

/*
================
idProgram::CreateThread
================
*/
sdProgramThread* idProgram::CreateThread( const sdScriptHelper& h ) {
	const function_t* function = reinterpret_cast< const function_t* >( h.GetFunction() );

	if ( function->parmTotal != h.GetSize() ) {
		gameLocal.Warning( "idProgram::CreateThread Function '%s' Called With Incorrect Number Of Arguments", function->GetName() );
		assert( false );
		return NULL;
	}

	idThread* thread = reinterpret_cast< idThread* >( CreateThread() );

	thread->ManualDelete();
	thread->ManualControl();

	thread->GetInterpreter().PushParm( h.GetObject()->GetHandle() );

	const sdScriptHelper::parmsList_t& args = h.GetArgs();
	for ( int i = 0; i < args.Num(); i++ ) {
		if ( args[ i ].string ) {
			thread->GetInterpreter().PushParm( args[ i ].string );
		} else {
			thread->GetInterpreter().PushParm( args[ i ].integer );
		}
	}

	thread->GetInterpreter().EnterFunction( function, false );

	return thread;
}

/*
================
idProgram::FreeThread
================
*/
void idProgram::FreeThread( sdProgramThread* thread ) {
	idThread::FreeThread( ( idThread* )thread );
}

/*
================
idProgram::FindFunction
================
*/
const sdProgram::sdFunction* idProgram::FindFunction( const char* name ) {
	return FindFunctionInternal( name );
}

/*
================
idProgram::FindFunction
================
*/
const sdProgram::sdFunction* idProgram::FindFunction( const char* name, const sdProgram::sdTypeObject* object ) {
	return FindFunctionInternal( name, reinterpret_cast< const idProgramTypeObject* >( object )->GetType() );
}

/*
================
idProgram::KillThread
================
*/
void idProgram::KillThread( int number ) {
	idThread::KillThread( number );
}

/*
================
idProgram::KillThread
================
*/
void idProgram::KillThread( const char* name ) {
	idThread::KillThread( name );
}

/*
================
idProgram::GetCurrentThread
================
*/
sdProgramThread* idProgram::GetCurrentThread( void ) {
	return idThread::CurrentThread();
}

/*
================
idProgram::AllocType
================
*/
sdProgram::sdTypeObject* idProgram::AllocType( sdProgram::sdTypeObject* oldType, const char* typeName ) {
	idTypeDef* typeDef = FindType( typeName );
	if ( typeDef == NULL ) {
		FreeType( oldType );
		gameLocal.Warning( "idProgram::AllocType: Unknown type '%s'", typeName );
		return NULL;
	}

	return AllocType( oldType, typeDef );
}

/*
================
idProgram::FreeType
================
*/
void idProgram::FreeType( sdProgram::sdTypeObject* oldType ) {
	delete oldType;
}

/*
================
idProgram::AllocType
================
*/
sdProgram::sdTypeObject* idProgram::AllocType( sdProgram::sdTypeObject* oldType, const sdProgram::sdTypeInfo* typeInfo ) {
	idProgramTypeObject* oldT = reinterpret_cast< idProgramTypeObject* >( oldType );

	assert( typeInfo );

	const idTypeDef* typeDef = reinterpret_cast< const idTypeDef* >( typeInfo );
	if ( !typeDef->Inherits( &type_object ) ) {
		FreeType( oldType );
		gameLocal.Warning( "idProgram::AllocType: Can't create object of type '%s'.  Must be an object type.", typeDef->Name() );
		return NULL;
	}

	idProgramTypeObject* newT = NULL;

	if ( oldT != NULL ) {
		if ( typeDef == oldT->GetType() ) {
			newT = oldT;
		} else {
			FreeType( oldType );
		}
	}

	if ( newT == NULL ) {
		newT = new idProgramTypeObject( typeDef );
	}

	newT->Clear();

	return newT;
}

/*
================
idProgram::FindTypeInfo
================
*/
const sdProgram::sdTypeInfo* idProgram::FindTypeInfo( const char *name ) {
	return FindType( name );
}

/*
================
idProgram::GetNumClasses
================
*/
int idProgram::GetNumClasses( void ) const {
	int count = 0;
	for ( int i = 0; i < types.Num(); i++ ) {
		if ( types[ i ]->Type() == ev_object ) {
			count++;
		}
	}
	return count;
}

/*
================
idProgram::GetClass
================
*/
const sdProgram::sdTypeInfo* idProgram::GetClass( int index ) const {
	int count = 0;
	for ( int i = 0; i < types.Num(); i++ ) {
		if ( types[ i ]->Type() == ev_object ) {
			if ( count == index ) {
				return types[ i ];
			}
			count++;
		}
	}
	return NULL;
}


/*
================
idProgram::ListThreads
================
*/
void idProgram::ListThreads( void ) const {
	idThread::ListThreads();

	int count = 0;
	int size = 0;
	for ( int i = 0; i < MAX_SCRIPT_STACK_SIZE_COUNT; i++ ) {
		int localCount = freeStacks[ i ].Num();
		size += ( ( i + 1 ) * 1024 ) * localCount;
		count += localCount;
	}

	gameLocal.Printf( "Total Free Thread Stacks: %d\n", count );
	gameLocal.Printf( "Total Free Thread Stack Size: %d\n", size );
}

/*
================
idProgram::PruneThreads
================
*/
void idProgram::PruneThreads( void ) {
	idThread::PruneThreads();
}

/*
================
idProgram::AllocStack
================
*/
byte* idProgram::AllocStack( int size ) {
	assert( ( ( size % 1024 ) == 0 ) && size <= 6144 );

	const int index = ( size / 1024 ) - 1;

	int num = freeStacks[ index ].Num();
	if ( num > 0 ) {
		byte* stack = freeStacks[ index ][ num - 1 ];
		freeStacks[ index ].SetNum( num - 1, false );
		return stack;
	}

	return new byte[ size ];
}

/*
================
idProgram::FreeStack
================
*/
void idProgram::FreeStack( byte* stack, int size ) {
	if ( stack == NULL ) {
		return;
	}

	assert( ( ( size % 1024 ) == 0 ) && size <= 6144 );

	const int index = ( size / 1024 ) - 1;

	freeStacks[ index ].Alloc() = stack;
}

/*
================
idProgram::OnError
================
*/
bool idProgram::OnError( const char* text ) {
	idThread* thread = idThread::CurrentThread();
	if ( thread == NULL ) {
		return false;
	}

	thread->Error( text );
	return true;
}

/*
================
idProgramTypeObject::GetVariable
================
*/
etype_t idProgramTypeObject::GetVariable( const char *name, byte** _data ) const {
	*_data = NULL;

	const idTypeDef* t = type;
	do {
		int pos;
		if ( t->SuperClass() != &type_object ) {
			pos = t->SuperClass()->Size();
		} else {
			pos = 0;
		}
		for( int i = 0; i < t->NumParameters(); i++ ) {
			const idTypeDef* parm = t->GetParmType( i );
			if ( !strcmp( t->GetParmName( i ), name ) ) {
				*_data = &data[ pos ];
				return parm->FieldType()->Type();
			}

			if ( parm->FieldType()->Inherits( &type_object ) ) {
				pos += type_object.Size();
			} else {
				pos += parm->FieldType()->Size();
			}
		}
		t = t->SuperClass();
	} while( t && ( t != &type_object ) );

	return ev_error;
}

/*
================
idProgramTypeObject::ValidateCall
================
*/
bool idProgramTypeObject::ValidateCall( const sdProgram::sdFunction* func ) const {
	const function_t* f = reinterpret_cast< const function_t* >( func );

	return type->Inherits( f->type->GetParmType( 0 ) );
}