DOOM-3-BFG

Script_Compiler.cpp (72994B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #pragma hdrstop
 #include "../../idlib/precompiled.h"
 
 
 #include "../Game_local.h"
 
 #define FUNCTION_PRIORITY	2
 #define INT_PRIORITY		2
 #define NOT_PRIORITY		5
 #define TILDE_PRIORITY		5
 #define TOP_PRIORITY		7
 
 bool idCompiler::punctuationValid[ 256 ];
 char *idCompiler::punctuation[] = {
 	"+=", "-=", "*=", "/=", "%=", "&=", "|=", "++", "--",
 	"&&", "||", "<=", ">=", "==", "!=", "::", ";",  ",",
 	"~",  "!",  "*",  "/",  "%",  "(",   ")",  "-", "+",
 	"=",  "[",  "]",  ".",  "<",  ">" ,  "&",  "|", ":",  NULL
 };
 
 opcode_t idCompiler::opcodes[] = {
 	{ "<RETURN>", "RETURN", -1, false, &def_void, &def_void, &def_void },
 		
 	{ "++", "UINC_F", 1, true, &def_float, &def_void, &def_void },
 	{ "++", "UINCP_F", 1, true, &def_object, &def_field, &def_float },
 	{ "--", "UDEC_F", 1, true, &def_float, &def_void, &def_void },
 	{ "--", "UDECP_F", 1, true, &def_object, &def_field, &def_float },
 
 	{ "~", "COMP_F", -1, false, &def_float, &def_void, &def_float },
 	
 	{ "*", "MUL_F", 3, false, &def_float, &def_float, &def_float },
 	{ "*", "MUL_V", 3, false, &def_vector, &def_vector, &def_float },
 	{ "*", "MUL_FV", 3, false, &def_float, &def_vector, &def_vector },
 	{ "*", "MUL_VF", 3, false, &def_vector, &def_float, &def_vector },
 	
 	{ "/", "DIV", 3, false, &def_float, &def_float, &def_float },
 	{ "%", "MOD_F",	3, false, &def_float, &def_float, &def_float },
 	
 	{ "+", "ADD_F", 4, false, &def_float, &def_float, &def_float },
 	{ "+", "ADD_V", 4, false, &def_vector, &def_vector, &def_vector },
 	{ "+", "ADD_S", 4, false, &def_string, &def_string, &def_string },
 	{ "+", "ADD_FS", 4, false, &def_float, &def_string, &def_string },
 	{ "+", "ADD_SF", 4, false, &def_string, &def_float, &def_string },
 	{ "+", "ADD_VS", 4, false, &def_vector, &def_string, &def_string },
 	{ "+", "ADD_SV", 4, false, &def_string, &def_vector, &def_string },
 	
 	{ "-", "SUB_F", 4, false, &def_float, &def_float, &def_float },
 	{ "-", "SUB_V", 4, false, &def_vector, &def_vector, &def_vector },
 	
 	{ "==", "EQ_F", 5, false, &def_float, &def_float, &def_float },
 	{ "==", "EQ_V", 5, false, &def_vector, &def_vector, &def_float },
 	{ "==", "EQ_S", 5, false, &def_string, &def_string, &def_float },
 	{ "==", "EQ_E", 5, false, &def_entity, &def_entity, &def_float },
 	{ "==", "EQ_EO", 5, false, &def_entity, &def_object, &def_float },
 	{ "==", "EQ_OE", 5, false, &def_object, &def_entity, &def_float },
 	{ "==", "EQ_OO", 5, false, &def_object, &def_object, &def_float },
 	
 	{ "!=", "NE_F", 5, false, &def_float, &def_float, &def_float },
 	{ "!=", "NE_V", 5, false, &def_vector, &def_vector, &def_float },
 	{ "!=", "NE_S", 5, false, &def_string, &def_string, &def_float },
     { "!=", "NE_E", 5, false, &def_entity, &def_entity, &def_float },
 	{ "!=", "NE_EO", 5, false, &def_entity, &def_object, &def_float },
 	{ "!=", "NE_OE", 5, false, &def_object, &def_entity, &def_float },
 	{ "!=", "NE_OO", 5, false, &def_object, &def_object, &def_float },
 	
 	{ "<=", "LE", 5, false, &def_float, &def_float, &def_float },
 	{ ">=", "GE", 5, false, &def_float, &def_float, &def_float },
 	{ "<", "LT", 5, false, &def_float, &def_float, &def_float },
 	{ ">", "GT", 5, false, &def_float, &def_float, &def_float },
 	
 	{ ".", "INDIRECT_F", 1, false, &def_object, &def_field, &def_float },
 	{ ".", "INDIRECT_V", 1, false, &def_object, &def_field, &def_vector },
 	{ ".", "INDIRECT_S", 1, false, &def_object, &def_field, &def_string },
 	{ ".", "INDIRECT_E", 1, false, &def_object, &def_field, &def_entity },
 	{ ".", "INDIRECT_BOOL", 1, false, &def_object, &def_field, &def_boolean },
 	{ ".", "INDIRECT_OBJ", 1, false, &def_object, &def_field, &def_object },
 
 	{ ".", "ADDRESS", 1, false, &def_entity, &def_field, &def_pointer },
 
 	{ ".", "EVENTCALL", 2, false, &def_entity, &def_function, &def_void },
 	{ ".", "OBJECTCALL", 2, false, &def_object, &def_function, &def_void },
 	{ ".", "SYSCALL", 2, false, &def_void, &def_function, &def_void },
 
 	{ "=", "STORE_F", 6, true, &def_float, &def_float, &def_float },
 	{ "=", "STORE_V", 6, true, &def_vector, &def_vector, &def_vector },
 	{ "=", "STORE_S", 6, true, &def_string, &def_string, &def_string },
 	{ "=", "STORE_ENT", 6, true, &def_entity, &def_entity, &def_entity },
 	{ "=", "STORE_BOOL", 6, true, &def_boolean, &def_boolean, &def_boolean },
 	{ "=", "STORE_OBJENT", 6, true, &def_object, &def_entity, &def_object },
 	{ "=", "STORE_OBJ", 6, true, &def_object, &def_object, &def_object },
 	{ "=", "STORE_OBJENT", 6, true, &def_entity, &def_object, &def_object },
 	
 	{ "=", "STORE_FTOS", 6, true, &def_string, &def_float, &def_string },
 	{ "=", "STORE_BTOS", 6, true, &def_string, &def_boolean, &def_string },
 	{ "=", "STORE_VTOS", 6, true, &def_string, &def_vector, &def_string },
 	{ "=", "STORE_FTOBOOL", 6, true, &def_boolean, &def_float, &def_boolean },
 	{ "=", "STORE_BOOLTOF", 6, true, &def_float, &def_boolean, &def_float },
 
 	{ "=", "STOREP_F", 6, true, &def_pointer, &def_float, &def_float },
 	{ "=", "STOREP_V", 6, true, &def_pointer, &def_vector, &def_vector },
 	{ "=", "STOREP_S", 6, true, &def_pointer, &def_string, &def_string },
 	{ "=", "STOREP_ENT", 6, true, &def_pointer, &def_entity, &def_entity },
 	{ "=", "STOREP_FLD", 6, true, &def_pointer, &def_field, &def_field },
 	{ "=", "STOREP_BOOL", 6, true, &def_pointer, &def_boolean, &def_boolean },
 	{ "=", "STOREP_OBJ", 6, true, &def_pointer, &def_object, &def_object },
 	{ "=", "STOREP_OBJENT", 6, true, &def_pointer, &def_object, &def_object },
 
 	{ "<=>", "STOREP_FTOS", 6, true, &def_pointer, &def_float, &def_string },
 	{ "<=>", "STOREP_BTOS", 6, true, &def_pointer, &def_boolean, &def_string },
 	{ "<=>", "STOREP_VTOS", 6, true, &def_pointer, &def_vector, &def_string },
 	{ "<=>", "STOREP_FTOBOOL", 6, true, &def_pointer, &def_float, &def_boolean },
 	{ "<=>", "STOREP_BOOLTOF", 6, true, &def_pointer, &def_boolean, &def_float },
 	
 	{ "*=", "UMUL_F", 6, true, &def_float, &def_float, &def_void },
 	{ "*=", "UMUL_V", 6, true, &def_vector, &def_float, &def_void },
 	{ "/=", "UDIV_F", 6, true, &def_float, &def_float, &def_void },
 	{ "/=", "UDIV_V", 6, true, &def_vector, &def_float, &def_void },
 	{ "%=", "UMOD_F", 6, true, &def_float, &def_float, &def_void },
 	{ "+=", "UADD_F", 6, true, &def_float, &def_float, &def_void },
 	{ "+=", "UADD_V", 6, true, &def_vector, &def_vector, &def_void },
 	{ "-=", "USUB_F", 6, true, &def_float, &def_float, &def_void },
 	{ "-=", "USUB_V", 6, true, &def_vector, &def_vector, &def_void },
 	{ "&=", "UAND_F", 6, true, &def_float, &def_float, &def_void },
 	{ "|=", "UOR_F", 6, true, &def_float, &def_float, &def_void },
 	
 	{ "!", "NOT_BOOL", -1, false, &def_boolean, &def_void, &def_float },
 	{ "!", "NOT_F", -1, false, &def_float, &def_void, &def_float },
 	{ "!", "NOT_V", -1, false, &def_vector, &def_void, &def_float },
 	{ "!", "NOT_S", -1, false, &def_vector, &def_void, &def_float },
 	{ "!", "NOT_ENT", -1, false, &def_entity, &def_void, &def_float },
 
 	{ "<NEG_F>", "NEG_F", -1, false, &def_float, &def_void, &def_float },
 	{ "<NEG_V>", "NEG_V", -1, false, &def_vector, &def_void, &def_vector },
 
 	{ "int", "INT_F", -1, false, &def_float, &def_void, &def_float },
 	
 	{ "<IF>", "IF", -1, false, &def_float, &def_jumpoffset, &def_void },
 	{ "<IFNOT>", "IFNOT", -1, false, &def_float, &def_jumpoffset, &def_void },
 	
 	// calls returns REG_RETURN
 	{ "<CALL>", "CALL", -1, false, &def_function, &def_argsize, &def_void },
 	{ "<THREAD>", "THREAD", -1, false, &def_function, &def_argsize, &def_void },
 	{ "<THREAD>", "OBJTHREAD", -1, false, &def_function, &def_argsize, &def_void },
 	
 	{ "<PUSH>", "PUSH_F", -1, false, &def_float, &def_float, &def_void },
 	{ "<PUSH>", "PUSH_V", -1, false, &def_vector, &def_vector, &def_void },
 	{ "<PUSH>", "PUSH_S", -1, false, &def_string, &def_string, &def_void },
 	{ "<PUSH>", "PUSH_ENT", -1, false, &def_entity, &def_entity, &def_void },
 	{ "<PUSH>", "PUSH_OBJ", -1, false, &def_object, &def_object, &def_void },
 	{ "<PUSH>", "PUSH_OBJENT", -1, false, &def_entity, &def_object, &def_void },
 	{ "<PUSH>", "PUSH_FTOS", -1, false, &def_string, &def_float, &def_void },
 	{ "<PUSH>", "PUSH_BTOF", -1, false, &def_float, &def_boolean, &def_void },
 	{ "<PUSH>", "PUSH_FTOB", -1, false, &def_boolean, &def_float, &def_void },
 	{ "<PUSH>", "PUSH_VTOS", -1, false, &def_string, &def_vector, &def_void },
 	{ "<PUSH>", "PUSH_BTOS", -1, false, &def_string, &def_boolean, &def_void },
 	
 	{ "<GOTO>", "GOTO", -1, false, &def_jumpoffset, &def_void, &def_void },
 	
 	{ "&&", "AND", 7, false, &def_float, &def_float, &def_float },
 	{ "&&", "AND_BOOLF", 7, false, &def_boolean, &def_float, &def_float },
 	{ "&&", "AND_FBOOL", 7, false, &def_float, &def_boolean, &def_float },
 	{ "&&", "AND_BOOLBOOL", 7, false, &def_boolean, &def_boolean, &def_float },
 	{ "||", "OR", 7, false, &def_float, &def_float, &def_float },
 	{ "||", "OR_BOOLF", 7, false, &def_boolean, &def_float, &def_float },
 	{ "||", "OR_FBOOL", 7, false, &def_float, &def_boolean, &def_float },
 	{ "||", "OR_BOOLBOOL", 7, false, &def_boolean, &def_boolean, &def_float },
 	
 	{ "&", "BITAND", 3, false, &def_float, &def_float, &def_float },
 	{ "|", "BITOR", 3, false, &def_float, &def_float, &def_float },
 
 	{ "<BREAK>", "BREAK", -1, false, &def_float, &def_void, &def_void },
 	{ "<CONTINUE>", "CONTINUE", -1, false, &def_float, &def_void, &def_void },
 
 	{ NULL }
 };
 
 /*
 ================
 idCompiler::idCompiler()
 ================
 */
 idCompiler::idCompiler() {
 	char	**ptr;
 	int		id;
 
 	// make sure we have the right # of opcodes in the table
 	assert( ( sizeof( opcodes ) / sizeof( opcodes[ 0 ] ) ) == ( NUM_OPCODES + 1 ) );
 
 	parserPtr = &parser;
 
 	callthread			= false;
 	loopDepth			= 0;
 	eof					= false;
 	braceDepth			= 0;
 	immediateType		= NULL;
 	basetype			= NULL;
 	currentLineNumber	= 0;
 	currentFileNumber	= 0;
 	errorCount			= 0;
 	console				= false;
 	scope				= &def_namespace;
 
 	memset( &immediate, 0, sizeof( immediate ) );
 	memset( punctuationValid, 0, sizeof( punctuationValid ) );
 	for( ptr = punctuation; *ptr != NULL; ptr++ ) {
 		id = parserPtr->GetPunctuationId( *ptr );
 		if ( ( id >= 0 ) && ( id < 256 ) ) {
 			punctuationValid[ id ] = true;
 		}
 	}
 }
 
 /*
 ============
 idCompiler::Error
 
 Aborts the current file load
 ============
 */
 void idCompiler::Error( const char *message, ... ) const {
 	va_list	argptr;
 	char	string[ 1024 ];
 
 	va_start( argptr, message );
 	vsprintf( string, message, argptr );
 	va_end( argptr );
 
 	throw idCompileError( string );
 }
 
 /*
 ============
 idCompiler::Warning
 
 Prints a warning about the current line
 ============
 */
 void idCompiler::Warning( const char *message, ... ) const {
 	va_list	argptr;
 	char	string[ 1024 ];
 
 	va_start( argptr, message );
 	vsprintf( string, message, argptr );
 	va_end( argptr );
 
 	parserPtr->Warning( "%s", string );
 }
 
 /*
 ============
 idCompiler::VirtualFunctionConstant
 
 Creates a def for an index into a virtual function table
 ============
 */
 ID_INLINE idVarDef *idCompiler::VirtualFunctionConstant( idVarDef *func ) {
 	eval_t eval;
 
 	memset( &eval, 0, sizeof( eval ) );
 	eval._int = func->scope->TypeDef()->GetFunctionNumber( func->value.functionPtr );
 	if ( eval._int < 0 ) {
 		Error( "Function '%s' not found in scope '%s'", func->Name(), func->scope->Name() );
 	}
     
 	return GetImmediate( &type_virtualfunction, &eval, "" );
 }
 
 /*
 ============
 idCompiler::SizeConstant
 
 Creates a def for a size constant
 ============
 */
 ID_INLINE idVarDef *idCompiler::SizeConstant( int size ) {
 	eval_t eval;
 
 	memset( &eval, 0, sizeof( eval ) );
 	eval._int = size;
 	return GetImmediate( &type_argsize, &eval, "" );
 }
 
 /*
 ============
 idCompiler::JumpConstant
 
 Creates a def for a jump constant
 ============
 */
 ID_INLINE idVarDef *idCompiler::JumpConstant( int value ) {
 	eval_t eval;
 
 	memset( &eval, 0, sizeof( eval ) );
 	eval._int = value;
 	return GetImmediate( &type_jumpoffset, &eval, "" );
 }
 
 /*
 ============
 idCompiler::JumpDef
 
 Creates a def for a relative jump from one code location to another
 ============
 */
 ID_INLINE idVarDef *idCompiler::JumpDef( int jumpfrom, int jumpto ) {
 	return JumpConstant( jumpto - jumpfrom );
 }
 
 /*
 ============
 idCompiler::JumpTo
 
 Creates a def for a relative jump from current code location
 ============
 */
 ID_INLINE idVarDef *idCompiler::JumpTo( int jumpto ) {
 	return JumpDef( gameLocal.program.NumStatements(), jumpto );
 }
 
 /*
 ============
 idCompiler::JumpFrom
 
 Creates a def for a relative jump from code location to current code location
 ============
 */
 ID_INLINE idVarDef *idCompiler::JumpFrom( int jumpfrom ) {
 	return JumpDef( jumpfrom, gameLocal.program.NumStatements() );
 }
 
 /*
 ============
 idCompiler::Divide
 ============
 */
 ID_INLINE float idCompiler::Divide( float numerator, float denominator ) {
 	if ( denominator == 0 ) {
 		Error( "Divide by zero" );
 	}
 
 	return numerator / denominator;
 }
 
 /*
 ============
 idCompiler::FindImmediate
 
 tries to find an existing immediate with the same value
 ============
 */
 idVarDef *idCompiler::FindImmediate( const idTypeDef *type, const eval_t *eval, const char *string ) const {
 	idVarDef	*def;
 	etype_t		etype;
 
 	etype = type->Type();
 
 	// check for a constant with the same value
 	for( def = gameLocal.program.GetDefList( "<IMMEDIATE>" ); def != NULL; def = def->Next() ) {
 		if ( def->TypeDef() != type ) {
 			continue;
 		}
 
 		switch( etype ) {
 		case ev_field :
 			if ( *def->value.intPtr == eval->_int ) {
 				return def;
 			}
 			break;
 
 		case ev_argsize :
 			if ( def->value.argSize == eval->_int ) {
 				return def;
 			}
 			break;
 
 		case ev_jumpoffset :
 			if ( def->value.jumpOffset == eval->_int ) {
 				return def;
 			}
 			break;
 
 		case ev_entity :
 			if ( *def->value.intPtr == eval->entity ) {
 				return def;
 			}
 			break;
 
 		case ev_string :
 			if ( idStr::Cmp( def->value.stringPtr, string ) == 0 ) {
 				return def;
 			}
 			break;
 
 		case ev_float :
 			if ( *def->value.floatPtr == eval->_float ) {
 				return def;
 			}
 			break;
 
 		case ev_virtualfunction :
 			if ( def->value.virtualFunction == eval->_int ) {
 				return def;
 			}
 			break;
 
 
 		case ev_vector :
 			if ( ( def->value.vectorPtr->x == eval->vector[ 0 ] ) && 
 				( def->value.vectorPtr->y == eval->vector[ 1 ] ) && 
 				( def->value.vectorPtr->z == eval->vector[ 2 ] ) ) {
 				return def;
 			}
 			break;
 
 		default :
 			Error( "weird immediate type" );
 			break;
 		}
 	}
 
 	return NULL;
 }
 
 /*
 ============
 idCompiler::GetImmediate
 
 returns an existing immediate with the same value, or allocates a new one
 ============
 */
 idVarDef *idCompiler::GetImmediate( idTypeDef *type, const eval_t *eval, const char *string ) {
 	idVarDef *def;
 
 	def = FindImmediate( type, eval, string );
 	if ( def ) {
 		def->numUsers++;
 	} else {
 		// allocate a new def
 		def = gameLocal.program.AllocDef( type, "<IMMEDIATE>", &def_namespace, true );
 		if ( type->Type() == ev_string ) {
 			def->SetString( string, true );
 		} else {
 			def->SetValue( *eval, true );
 		}
 	}
 
 	return def;
 }
 
 /*
 ============
 idCompiler::OptimizeOpcode
 
 try to optimize when the operator works on constants only
 ============
 */
 idVarDef *idCompiler::OptimizeOpcode( const opcode_t *op, idVarDef *var_a, idVarDef *var_b ) {
 	eval_t		c;
 	idTypeDef	*type;
 
 	if ( var_a == NULL || var_a->initialized != idVarDef::initializedConstant ) {
 		return NULL;
 	}
 	if ( var_b == NULL || var_b->initialized != idVarDef::initializedConstant ) {
 		return NULL;
 	}
 
 	idVec3 &vec_c = *reinterpret_cast<idVec3 *>( &c.vector[ 0 ] );
 
 	memset( &c, 0, sizeof( c ) );
 	switch( op - opcodes ) {
 		case OP_ADD_F:		c._float = *var_a->value.floatPtr + *var_b->value.floatPtr; type = &type_float; break;
 		case OP_ADD_V:		vec_c = *var_a->value.vectorPtr + *var_b->value.vectorPtr; type = &type_vector; break;
 		case OP_SUB_F:		c._float = *var_a->value.floatPtr - *var_b->value.floatPtr; type = &type_float; break;
 		case OP_SUB_V:		vec_c = *var_a->value.vectorPtr - *var_b->value.vectorPtr; type = &type_vector; break;
 		case OP_MUL_F:		c._float = *var_a->value.floatPtr * *var_b->value.floatPtr; type = &type_float; break;
 		case OP_MUL_V:		c._float = *var_a->value.vectorPtr * *var_b->value.vectorPtr; type = &type_float; break;
 		case OP_MUL_FV:		vec_c = *var_b->value.vectorPtr * *var_a->value.floatPtr; type = &type_vector; break;
 		case OP_MUL_VF:		vec_c = *var_a->value.vectorPtr * *var_b->value.floatPtr; type = &type_vector; break;
 		case OP_DIV_F:		c._float = Divide( *var_a->value.floatPtr, *var_b->value.floatPtr ); type = &type_float; break;
 		case OP_MOD_F:		c._float = (int)*var_a->value.floatPtr % (int)*var_b->value.floatPtr; type = &type_float; break;
 		case OP_BITAND:		c._float = ( int )*var_a->value.floatPtr & ( int )*var_b->value.floatPtr; type = &type_float; break;
 		case OP_BITOR:		c._float = ( int )*var_a->value.floatPtr | ( int )*var_b->value.floatPtr; type = &type_float; break;
 		case OP_GE:			c._float = *var_a->value.floatPtr >= *var_b->value.floatPtr; type = &type_float; break;
 		case OP_LE:			c._float = *var_a->value.floatPtr <= *var_b->value.floatPtr; type = &type_float; break;
 		case OP_GT:			c._float = *var_a->value.floatPtr > *var_b->value.floatPtr; type = &type_float; break;
 		case OP_LT:			c._float = *var_a->value.floatPtr < *var_b->value.floatPtr; type = &type_float; break;
 		case OP_AND:		c._float = *var_a->value.floatPtr && *var_b->value.floatPtr; type = &type_float; break;
 		case OP_OR:			c._float = *var_a->value.floatPtr || *var_b->value.floatPtr; type = &type_float; break;
 		case OP_NOT_BOOL:	c._int = !*var_a->value.intPtr; type = &type_boolean; break;
 		case OP_NOT_F:		c._float = !*var_a->value.floatPtr; type = &type_float; break;
 		case OP_NOT_V:		c._float = !var_a->value.vectorPtr->x && !var_a->value.vectorPtr->y && !var_a->value.vectorPtr->z; type = &type_float; break;
 		case OP_NEG_F:		c._float = -*var_a->value.floatPtr; type = &type_float; break;
 		case OP_NEG_V:		vec_c = -*var_a->value.vectorPtr; type = &type_vector; break;
 		case OP_INT_F:		c._float = ( int )*var_a->value.floatPtr; type = &type_float; break;
 		case OP_EQ_F:		c._float = ( *var_a->value.floatPtr == *var_b->value.floatPtr ); type = &type_float; break;
 		case OP_EQ_V:		c._float = var_a->value.vectorPtr->Compare( *var_b->value.vectorPtr ); type = &type_float; break;
 		case OP_EQ_E:		c._float = ( *var_a->value.intPtr == *var_b->value.intPtr ); type = &type_float; break;
 		case OP_NE_F:		c._float = ( *var_a->value.floatPtr != *var_b->value.floatPtr ); type = &type_float; break;
 		case OP_NE_V:		c._float = !var_a->value.vectorPtr->Compare( *var_b->value.vectorPtr ); type = &type_float; break;
 		case OP_NE_E:		c._float = ( *var_a->value.intPtr != *var_b->value.intPtr ); type = &type_float; break;
 		case OP_UADD_F:		c._float = *var_b->value.floatPtr + *var_a->value.floatPtr; type = &type_float; break;
 		case OP_USUB_F:		c._float = *var_b->value.floatPtr - *var_a->value.floatPtr; type = &type_float; break;
 		case OP_UMUL_F:		c._float = *var_b->value.floatPtr * *var_a->value.floatPtr; type = &type_float; break;
 		case OP_UDIV_F:		c._float = Divide( *var_b->value.floatPtr, *var_a->value.floatPtr ); type = &type_float; break;
 		case OP_UMOD_F:		c._float = ( int ) *var_b->value.floatPtr % ( int )*var_a->value.floatPtr; type = &type_float; break;
 		case OP_UOR_F:		c._float = ( int )*var_b->value.floatPtr | ( int )*var_a->value.floatPtr; type = &type_float; break;
 		case OP_UAND_F: 	c._float = ( int )*var_b->value.floatPtr & ( int )*var_a->value.floatPtr; type = &type_float; break;
 		case OP_UINC_F:		c._float = *var_a->value.floatPtr + 1; type = &type_float; break;
 		case OP_UDEC_F:		c._float = *var_a->value.floatPtr - 1; type = &type_float; break;
 		case OP_COMP_F:		c._float = ( float )~( int )*var_a->value.floatPtr; type = &type_float; break;
 		default:			type = NULL; break;
 	}
 
 	if ( !type ) {
 		return NULL;
 	}
 
 	if ( var_a ) {
 		var_a->numUsers--;
 		if ( var_a->numUsers <= 0 ) {
 			gameLocal.program.FreeDef( var_a, NULL );
 		}
 	}
 	if ( var_b ) {
 		var_b->numUsers--;
 		if ( var_b->numUsers <= 0 ) {
 			gameLocal.program.FreeDef( var_b, NULL );
 		}
 	}
 
 	return GetImmediate( type, &c, "" );
 }
 
 /*
 ============
 idCompiler::EmitOpcode
 
 Emits a primitive statement, returning the var it places it's value in
 ============
 */
 idVarDef *idCompiler::EmitOpcode( const opcode_t *op, idVarDef *var_a, idVarDef *var_b ) {
 	statement_t	*statement;
 	idVarDef	*var_c;
 
 	var_c = OptimizeOpcode( op, var_a, var_b );
 	if ( var_c ) {
 		return var_c;
 	}
 
 	if ( var_a && !strcmp( var_a->Name(), RESULT_STRING ) ) {
 		var_a->numUsers++;
 	}
 	if ( var_b && !strcmp( var_b->Name(), RESULT_STRING ) ) {
 		var_b->numUsers++;
 	}
 	
 	statement = gameLocal.program.AllocStatement();
 	statement->linenumber	= currentLineNumber;
 	statement->file 		= currentFileNumber;
 	
 	if ( ( op->type_c == &def_void ) || op->rightAssociative ) {
 		// ifs, gotos, and assignments don't need vars allocated
 		var_c = NULL;
 	} else {
 		// allocate result space
 		// try to reuse result defs as much as possible
 		var_c = gameLocal.program.FindFreeResultDef( op->type_c->TypeDef(), RESULT_STRING, scope, var_a, var_b );
 		// set user count back to 1, a result def needs to be used twice before it can be reused
 		var_c->numUsers = 1;
 	}
 
 	statement->op	= op - opcodes;
 	statement->a	= var_a;
 	statement->b	= var_b;
 	statement->c	= var_c;
 
 	if ( op->rightAssociative ) {
 		return var_a;
 	}
 
 	return var_c;
 }
 
 /*
 ============
 idCompiler::EmitOpcode
 
 Emits a primitive statement, returning the var it places it's value in
 ============
 */
 ID_INLINE idVarDef *idCompiler::EmitOpcode( int op, idVarDef *var_a, idVarDef *var_b ) {
 	return EmitOpcode( &opcodes[ op ], var_a, var_b );
 }
 
 /*
 ============
 idCompiler::EmitPush
 
 Emits an opcode to push the variable onto the stack.
 ============
 */
 bool idCompiler::EmitPush( idVarDef *expression, const idTypeDef *funcArg ) {
 	opcode_t *op;
 	opcode_t *out;
 
 	out = NULL;
 	for( op = &opcodes[ OP_PUSH_F ]; op->name && !strcmp( op->name, "<PUSH>" ); op++ ) {
 		if ( ( funcArg->Type() == op->type_a->Type() ) && ( expression->Type() == op->type_b->Type() ) ) {
 			out = op;
 			break;
 		}
 	}
 
 	if ( !out ) {
 		if ( ( expression->TypeDef() != funcArg ) && !expression->TypeDef()->Inherits( funcArg ) ) {
 			return false;
 		}
 
 		out = &opcodes[ OP_PUSH_ENT ];
 	}
 
 	EmitOpcode( out, expression, 0 );
 
 	return true;
 }
 
 /*
 ==============
 idCompiler::NextToken
 
 Sets token, immediateType, and possibly immediate
 ==============
 */
 void idCompiler::NextToken() {
 	int i;
 
 	// reset our type
 	immediateType = NULL;
 	memset( &immediate, 0, sizeof( immediate ) );
 
 	// Save the token's line number and filename since when we emit opcodes the current 
 	// token is always the next one to be read 
 	currentLineNumber = token.line;
 	currentFileNumber = gameLocal.program.GetFilenum( parserPtr->GetFileName() );
 
 	if ( !parserPtr->ReadToken( &token ) ) {
 		eof = true;
 		return;
 	}
 
 	if ( currentFileNumber != gameLocal.program.GetFilenum( parserPtr->GetFileName() ) ) {
 		if ( ( braceDepth > 0 ) && ( token != "}" ) ) {
 			// missing a closing brace.  try to give as much info as possible.
 			if ( scope->Type() == ev_function ) {
 				Error( "Unexpected end of file inside function '%s'.  Missing closing braces.", scope->Name() );
 			} else if ( scope->Type() == ev_object ) {
 				Error( "Unexpected end of file inside object '%s'.  Missing closing braces.", scope->Name() );
 			} else if ( scope->Type() == ev_namespace ) {
 				Error( "Unexpected end of file inside namespace '%s'.  Missing closing braces.", scope->Name() );
 			} else {
 				Error( "Unexpected end of file inside braced section" );
 			}
 		}
 	}
 
 	switch( token.type ) {
 	case TT_STRING:
 		// handle quoted strings as a unit
 		immediateType = &type_string;
 		return;
 
 	case TT_LITERAL: {
 		// handle quoted vectors as a unit
 		immediateType = &type_vector;
 		idLexer lex( token, token.Length(), parserPtr->GetFileName(), LEXFL_NOERRORS );
 		idToken token2;
 		for( i = 0; i < 3; i++ ) {
 			if ( !lex.ReadToken( &token2 ) ) {
 				Error( "Couldn't read vector. '%s' is not in the form of 'x y z'", token.c_str() );
 			}
 			if ( token2.type == TT_PUNCTUATION && token2 == "-" ) {
 				if ( !lex.CheckTokenType( TT_NUMBER, 0, &token2 ) ) {
 					Error( "expected a number following '-' but found '%s' in vector '%s'", token2.c_str(), token.c_str() );
 				}
 				immediate.vector[ i ] = -token2.GetFloatValue();
 			} else if ( token2.type == TT_NUMBER ) {
 				immediate.vector[ i ] = token2.GetFloatValue();
 			} else {
 				Error( "vector '%s' is not in the form of 'x y z'.  expected float value, found '%s'", token.c_str(), token2.c_str() );
 			}
 		}
 		return;
 	}
 
 	case TT_NUMBER:
 		immediateType = &type_float;
 		immediate._float = token.GetFloatValue();
 		return;
 
 	case TT_PUNCTUATION:
 		// entity names
 		if ( token == "$" ) {
 			immediateType = &type_entity;
 			parserPtr->ReadToken( &token );
 			return;
 		}
 
 		if ( token == "{" ) {
 			braceDepth++;
 			return;
 		}
 
 		if ( token == "}" ) {
 			braceDepth--;
 			return;
 		}
 
 		if ( punctuationValid[ token.subtype ] ) {
 			return;
 		}
 
 		Error( "Unknown punctuation '%s'", token.c_str() );
 		break;
 
 	case TT_NAME:
 		return;
 
 	default:
 		Error( "Unknown token '%s'", token.c_str() );
 	}
 }
 
 /*
 =============
 idCompiler::ExpectToken
 
 Issues an Error if the current token isn't equal to string
 Gets the next token
 =============
 */
 void idCompiler::ExpectToken( const char *string ) {
 	if ( token != string ) {
 		Error( "expected '%s', found '%s'", string, token.c_str() );
 	}
 
 	NextToken();
 }
 
 /*
 =============
 idCompiler::CheckToken
 
 Returns true and gets the next token if the current token equals string
 Returns false and does nothing otherwise
 =============
 */
 bool idCompiler::CheckToken( const char *string ) {
 	if ( token != string ) {
 		return false;
 	}
 		
 	NextToken();
 	
 	return true;
 }
 
 /*
 ============
 idCompiler::ParseName
 
 Checks to see if the current token is a valid name
 ============
 */
 void idCompiler::ParseName( idStr &name ) {
 	if ( token.type != TT_NAME ) {
 		Error( "'%s' is not a name", token.c_str() );
 	}
 
 	name = token;
 	NextToken();
 }
 
 /*
 ============
 idCompiler::SkipOutOfFunction
 
 For error recovery, pops out of nested braces
 ============
 */
 void idCompiler::SkipOutOfFunction() {
 	while( braceDepth ) {
 		parserPtr->SkipBracedSection( false );
 		braceDepth--;
 	}
 	NextToken();
 }
 
 /*
 ============
 idCompiler::SkipToSemicolon
 
 For error recovery
 ============
 */
 void idCompiler::SkipToSemicolon() {
 	do {
 		if ( CheckToken( ";" ) ) {
 			return;
 		}
 
 		NextToken();
 	} while( !eof );
 }
 
 /*
 ============
 idCompiler::CheckType
 
 Parses a variable type, including functions types
 ============
 */
 idTypeDef *idCompiler::CheckType() {
 	idTypeDef *type;
 	
 	if ( token == "float" ) {
 		type = &type_float;
 	} else if ( token == "vector" ) {
 		type = &type_vector;
 	} else if ( token == "entity" ) {
 		type = &type_entity;
 	} else if ( token == "string" ) {
 		type = &type_string;
 	} else if ( token == "void" ) {
 		type = &type_void;
 	} else if ( token == "object" ) {
 		type = &type_object;
 	} else if ( token == "boolean" ) {
 		type = &type_boolean;
 	} else if ( token == "namespace" ) {
 		type = &type_namespace;
 	} else if ( token == "scriptEvent" ) {
 		type = &type_scriptevent;
 	} else {
 		type = gameLocal.program.FindType( token.c_str() );
 		if ( type != NULL && !type->Inherits( &type_object ) ) {
 			type = NULL;
 		}
 	}
 	
 	return type;
 }
 
 /*
 ============
 idCompiler::ParseType
 
 Parses a variable type, including functions types
 ============
 */
 idTypeDef *idCompiler::ParseType() {
 	idTypeDef *type;
 	
 	type = CheckType();
 	if ( !type ) {
 		Error( "\"%s\" is not a type", token.c_str() );
 	}
 
 	if ( ( type == &type_scriptevent ) && ( scope != &def_namespace ) ) {
 		Error( "scriptEvents can only defined in the global namespace" );
 	}
 
 	if ( ( type == &type_namespace ) && ( scope->Type() != ev_namespace ) ) {
 		Error( "A namespace may only be defined globally, or within another namespace" );
 	}
 
 	NextToken();
 	
 	return type;
 }
 
 /*
 ============
 idCompiler::ParseImmediate
 
 Looks for a preexisting constant
 ============
 */
 idVarDef *idCompiler::ParseImmediate() {
 	idVarDef *def;
 
 	def = GetImmediate( immediateType, &immediate, token.c_str() );
 	NextToken();
 
 	return def;
 }
 
 /*
 ============
 idCompiler::EmitFunctionParms
 ============
 */
 idVarDef *idCompiler::EmitFunctionParms( int op, idVarDef *func, int startarg, int startsize, idVarDef *object ) {
 	idVarDef		*e;
 	const idTypeDef	*type;
 	const idTypeDef	*funcArg;
 	idVarDef		*returnDef;
 	idTypeDef		*returnType;
 	int 			arg;
 	int 			size;
 	int				resultOp;
 
 	type = func->TypeDef();
 	if ( func->Type() != ev_function ) {
 		Error( "'%s' is not a function", func->Name() );
 	}
 
 	// copy the parameters to the global parameter variables
 	arg = startarg;
 	size = startsize;
 	if ( !CheckToken( ")" ) ) {
 		do {
 			if ( arg >= type->NumParameters() ) {
 				Error( "too many parameters" );
 			}
 
 			e = GetExpression( TOP_PRIORITY );
 
 			funcArg = type->GetParmType( arg );
 			if ( !EmitPush( e, funcArg ) ) {
 				Error( "type mismatch on parm %i of call to '%s'", arg + 1, func->Name() );
 			}
 
 			if ( funcArg->Type() == ev_object ) {
 				size += type_object.Size();
 			} else {
 				size += funcArg->Size();
 			}
 
 			arg++;
 		} while( CheckToken( "," ) );
 	
 		ExpectToken( ")" );
 	}
 
 	if ( arg < type->NumParameters() ) {
 		Error( "too few parameters for function '%s'", func->Name() );
 	}
 
 	if ( op == OP_CALL ) {
 		EmitOpcode( op, func, 0 );
 	} else if ( ( op == OP_OBJECTCALL ) || ( op == OP_OBJTHREAD ) ) {
 		EmitOpcode( op, object, VirtualFunctionConstant( func ) );
 
 		// need arg size seperate since script object may be NULL
 		statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
 		statement.c = SizeConstant( func->value.functionPtr->parmTotal );
 	} else {
 		EmitOpcode( op, func, SizeConstant( size ) );
 	}
 
 	// we need to copy off the result into a temporary result location, so figure out the opcode
 	returnType = type->ReturnType();
 	if ( returnType->Type() == ev_string ) {
 		resultOp = OP_STORE_S;
 		returnDef = gameLocal.program.returnStringDef;
 	} else {
 		gameLocal.program.returnDef->SetTypeDef( returnType );
 		returnDef = gameLocal.program.returnDef;
 
 		switch( returnType->Type() ) {
 		case ev_void :
 			resultOp = OP_STORE_F;
 			break;
 
 		case ev_boolean :
 			resultOp = OP_STORE_BOOL;
 			break;
 
 		case ev_float :
 			resultOp = OP_STORE_F;
 			break;
 
 		case ev_vector :
 			resultOp = OP_STORE_V;
 			break;
 
 		case ev_entity :
 			resultOp = OP_STORE_ENT;
 			break;
 
 		case ev_object :
 			resultOp = OP_STORE_OBJ;
 			break;
 
 		default :
 			// shut up compiler
 			resultOp = OP_STORE_OBJ;
 			Error( "Invalid return type for function '%s'", func->Name() );
 		}
 	}
 
 	if ( returnType->Type() == ev_void ) {
 		// don't need result space since there's no result, so just return the normal result def.
 		return returnDef;
 	}
 
 	// allocate result space
 	// try to reuse result defs as much as possible
 	statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
 	idVarDef *resultDef = gameLocal.program.FindFreeResultDef( returnType, RESULT_STRING, scope, statement.a, statement.b );
 	// set user count back to 0, a result def needs to be used twice before it can be reused
 	resultDef->numUsers = 0;
 
 	EmitOpcode( resultOp, returnDef, resultDef );
 
 	return resultDef;
 }
 
 /*
 ============
 idCompiler::ParseFunctionCall
 ============
 */
 idVarDef *idCompiler::ParseFunctionCall( idVarDef *funcDef ) {
 	assert( funcDef );
 
 	if ( funcDef->Type() != ev_function ) {
 		Error( "'%s' is not a function", funcDef->Name() );
 	}
 
 	if ( funcDef->initialized == idVarDef::uninitialized ) {
 		Error( "Function '%s' has not been defined yet", funcDef->GlobalName() );
 	}
 
 	assert( funcDef->value.functionPtr );
 	if ( callthread ) {
 		if ( ( funcDef->initialized != idVarDef::uninitialized ) && funcDef->value.functionPtr->eventdef ) {
 			Error( "Built-in functions cannot be called as threads" );
 		}
 		callthread = false;
 		return EmitFunctionParms( OP_THREAD, funcDef, 0, 0, NULL );
 	} else {
 		if ( ( funcDef->initialized != idVarDef::uninitialized ) && funcDef->value.functionPtr->eventdef ) {
 			if ( ( scope->Type() != ev_namespace ) && ( scope->scope->Type() == ev_object ) ) {
 				// get the local object pointer
 				idVarDef *thisdef = gameLocal.program.GetDef( scope->scope->TypeDef(), "self", scope );
 				if ( !thisdef ) {
 					Error( "No 'self' within scope" );
 				}
 
 				return ParseEventCall( thisdef, funcDef );
 			} else {
 				Error( "Built-in functions cannot be called without an object" );
 			}
 		}
 
 		return EmitFunctionParms( OP_CALL, funcDef, 0, 0, NULL );
 	}
 }
 
 /*
 ============
 idCompiler::ParseObjectCall
 ============
 */
 idVarDef *idCompiler::ParseObjectCall( idVarDef *object, idVarDef *func ) {
 	EmitPush( object, object->TypeDef() );
 	if ( callthread ) {
 		callthread = false;
 		return EmitFunctionParms( OP_OBJTHREAD, func, 1, type_object.Size(), object );
 	} else {
 		return EmitFunctionParms( OP_OBJECTCALL, func, 1, 0, object );
 	}
 }
 
 /*
 ============
 idCompiler::ParseEventCall
 ============
 */
 idVarDef *idCompiler::ParseEventCall( idVarDef *object, idVarDef *funcDef ) {
 	if ( callthread ) {
 		Error( "Cannot call built-in functions as a thread" );
 	}
 
 	if ( funcDef->Type() != ev_function ) {
 		Error( "'%s' is not a function", funcDef->Name() );
 	}
 
 	if ( !funcDef->value.functionPtr->eventdef ) {
 		Error( "\"%s\" cannot be called with object notation", funcDef->Name() );
 	}
 
 	if ( object->Type() == ev_object ) {
 		EmitPush( object, &type_entity );
 	} else {
 		EmitPush( object, object->TypeDef() );
 	}
 
 	return EmitFunctionParms( OP_EVENTCALL, funcDef, 0, type_object.Size(), NULL );
 }
 
 /*
 ============
 idCompiler::ParseSysObjectCall
 ============
 */
 idVarDef *idCompiler::ParseSysObjectCall( idVarDef *funcDef ) {
 	if ( callthread ) {
 		Error( "Cannot call built-in functions as a thread" );
 	}
 
 	if ( funcDef->Type() != ev_function ) {
 		Error( "'%s' is not a function", funcDef->Name() );
 	}
 
 	if ( funcDef->value.functionPtr->eventdef == NULL ) {
 		Error( "\"%s\" cannot be called with object notation", funcDef->Name() );
 	}
 
 	assert( funcDef->value.functionPtr->eventdef != NULL ); // to remove stupid analyze warning
 	if ( !idThread::Type.RespondsTo( *funcDef->value.functionPtr->eventdef ) ) {
 		Error( "\"%s\" is not callable as a 'sys' function", funcDef->Name() );
 	}
 
 	return EmitFunctionParms( OP_SYSCALL, funcDef, 0, 0, NULL );
 }
 
 /*
 ============
 idCompiler::LookupDef
 ============
 */
 idVarDef *idCompiler::LookupDef( const char *name, const idVarDef *baseobj ) {
 	idVarDef	*def;
 	idVarDef	*field;
 	etype_t		type_b;
 	etype_t		type_c;
 	opcode_t	*op;
 
 	// check if we're accessing a field
 	if ( baseobj && ( baseobj->Type() == ev_object ) ) {
 		const idVarDef *tdef;
 
 		def = NULL;
 		for( tdef = baseobj; tdef != &def_object; tdef = tdef->TypeDef()->SuperClass()->def ) {
 			def = gameLocal.program.GetDef( NULL, name, tdef );
 			if ( def ) {
 				break;
 			}
 		}
 	} else {
 		// first look through the defs in our scope
 		def = gameLocal.program.GetDef( NULL, name, scope );
 		if ( !def ) {
 			// if we're in a member function, check types local to the object
 			if ( ( scope->Type() != ev_namespace ) && ( scope->scope->Type() == ev_object ) ) {
 				// get the local object pointer
 				idVarDef *thisdef = gameLocal.program.GetDef( scope->scope->TypeDef(), "self", scope );
 
 				field = LookupDef( name, scope->scope->TypeDef()->def );
 				if ( !field ) {
 					Error( "Unknown value \"%s\"", name );
 				}
 
 				// type check
 				type_b = field->Type();
 				if ( field->Type() == ev_function ) {
 					type_c = field->TypeDef()->ReturnType()->Type();
 				} else {
 					type_c = field->TypeDef()->FieldType()->Type();	// field access gets type from field
 	                if ( CheckToken( "++" ) ) {
 						if ( type_c != ev_float ) {
 							Error( "Invalid type for ++" );
 						}
 						def = EmitOpcode( OP_UINCP_F, thisdef, field );
 						return def;
 					} else if ( CheckToken( "--" ) ) {
 						if ( type_c != ev_float ) {
 							Error( "Invalid type for --" );
 						}
 						def = EmitOpcode( OP_UDECP_F, thisdef, field );
 						return def;
 					}
 				}
 
 				op = &opcodes[ OP_INDIRECT_F ];
 				while( ( op->type_a->Type() != ev_object ) 
 					|| ( type_b != op->type_b->Type() ) || ( type_c != op->type_c->Type() ) ) {
 					if ( ( op->priority == FUNCTION_PRIORITY ) && ( op->type_a->Type() == ev_object ) && ( op->type_c->Type() == ev_void ) && 
 						( type_c != op->type_c->Type() ) ) {
 						// catches object calls that return a value
 						break;
 					}
 					op++;
 					if ( !op->name || strcmp( op->name, "." ) ) {
 						Error( "no valid opcode to access type '%s'", field->TypeDef()->SuperClass()->Name() );
 					}
 				}
 
 				if ( ( op - opcodes ) == OP_OBJECTCALL ) {
 					ExpectToken( "(" );
 					def = ParseObjectCall( thisdef, field );
 				} else {
 					// emit the conversion opcode
 					def = EmitOpcode( op, thisdef, field );
 
 					// field access gets type from field
 					def->SetTypeDef( field->TypeDef()->FieldType() );
 				}
 			}
 		}
 	}
 
 	return def;
 }
 
 /*
 ============
 idCompiler::ParseValue
 
 Returns the def for the current token
 ============
 */
 idVarDef *idCompiler::ParseValue() {
 	idVarDef	*def;
 	idVarDef	*namespaceDef;
 	idStr		name;
 	
 	if ( immediateType == &type_entity ) {
 		// if an immediate entity ($-prefaced name) then create or lookup a def for it.
 		// when entities are spawned, they'll lookup the def and point it to them.
 		def = gameLocal.program.GetDef( &type_entity, "$" + token, &def_namespace );
 		if ( !def ) {
 			def = gameLocal.program.AllocDef( &type_entity, "$" + token, &def_namespace, true );
 		}
 		NextToken();
 		return def;
 	} else if ( immediateType ) {
 		// if the token is an immediate, allocate a constant for it
 		return ParseImmediate();
 	}
 
 	ParseName( name );
 	def = LookupDef( name, basetype );
 	if ( def == NULL ) {
 		if ( basetype ) {
 			Error( "%s is not a member of %s", name.c_str(), basetype->TypeDef()->Name() );
 		} else {
 			Error( "Unknown value \"%s\"", name.c_str() );
 		}
 	// if namespace, then look up the variable in that namespace
 	} else if ( def->Type() == ev_namespace ) {
 		while( def->Type() == ev_namespace ) {
 			ExpectToken( "::" );
 			ParseName( name );
 			namespaceDef = def;
 			def = gameLocal.program.GetDef( NULL, name, namespaceDef );
 			if ( def == NULL ) {
 				if ( namespaceDef != NULL ) {
 					Error( "Unknown value \"%s::%s\"", namespaceDef->GlobalName(), name.c_str() );
 				} else {
 					Error( "Unknown value \"%s\"", name.c_str() );
 				}
 				break;
 			}
 		}
 		//def = LookupDef( name, basetype );
 	}
 
 	return def;
 }
 
 /*
 ============
 idCompiler::GetTerm
 ============
 */
 idVarDef *idCompiler::GetTerm() {
 	idVarDef	*e;
 	int 		op;
 	
 	if ( !immediateType && CheckToken( "~" ) ) {
 		e = GetExpression( TILDE_PRIORITY );
 		switch( e->Type() ) {
 		case ev_float :
 			op = OP_COMP_F;
 			break;
 
 		default :
 			// shut up compiler
 			op = OP_COMP_F;
 			Error( "type mismatch for ~" );
 		}
 
 		return EmitOpcode( op, e, 0 );
 	}
 
 	if ( !immediateType && CheckToken( "!" ) ) {
 		e = GetExpression( NOT_PRIORITY );
 		switch( e->Type() ) {
 		case ev_boolean :
 			op = OP_NOT_BOOL;
 			break;
 
 		case ev_float :
 			op = OP_NOT_F;
 			break;
 
 		case ev_string :
 			op = OP_NOT_S;
 			break;
 
 		case ev_vector :
 			op = OP_NOT_V;
 			break;
 
 		case ev_entity :
 			op = OP_NOT_ENT;
 			break;
 
 		case ev_function :
 			// shut up compiler
 			op = OP_NOT_F;
 			Error( "Invalid type for !" );
 			break;
 		case ev_object :
 			op = OP_NOT_ENT;
 			break;
 
 		default :
 			// shut up compiler
 			op = OP_NOT_F;
 			Error( "type mismatch for !" );
 		}
 
 		return EmitOpcode( op, e, 0 );
 	}
 
 	// check for negation operator
 	if ( !immediateType && CheckToken( "-" ) ) {
 		// constants are directly negated without an instruction
 		if ( immediateType == &type_float ) {
 			immediate._float = -immediate._float;
 			return ParseImmediate();
 		} else if ( immediateType == &type_vector ) {
 			immediate.vector[0] = -immediate.vector[0];
 			immediate.vector[1] = -immediate.vector[1];
 			immediate.vector[2] = -immediate.vector[2];
 			return ParseImmediate();
 		} else {
 			e = GetExpression( NOT_PRIORITY );
 			switch( e->Type() ) {
 			case ev_float :
 				op = OP_NEG_F;
 				break;
 
 			case ev_vector :
 				op = OP_NEG_V;
 				break;
 			default :
 				// shut up compiler
 				op = OP_NEG_F;
 				Error( "type mismatch for -" );
 			}
 			return EmitOpcode( &opcodes[ op ], e, 0 );
 		}
 	}
 	
 	if ( CheckToken( "int" ) ) {
 		ExpectToken( "(" );
 
 		e = GetExpression( INT_PRIORITY );
 		if ( e->Type() != ev_float ) {
 			Error( "type mismatch for int()" );
 		}
 
 		ExpectToken( ")" );
 
 		return EmitOpcode( OP_INT_F, e, 0 );
 	}
 	
 	if ( CheckToken( "thread" ) ) {
 		callthread = true;
 		e = GetExpression( FUNCTION_PRIORITY );
 
 		if ( callthread ) {
 			Error( "Invalid thread call" );
 		}
 
 		// threads return the thread number
 		gameLocal.program.returnDef->SetTypeDef( &type_float );
 		return gameLocal.program.returnDef;
 	}
 	
 	if ( !immediateType && CheckToken( "(" ) ) {
 		e = GetExpression( TOP_PRIORITY );
 		ExpectToken( ")" );
 
 		return e;
 	}
 	
 	return ParseValue();
 }
 
 /*
 ==============
 idCompiler::TypeMatches
 ==============
 */
 bool idCompiler::TypeMatches( etype_t type1, etype_t type2 ) const {
 	if ( type1 == type2 ) {
 		return true;
 	}
 
 	//if ( ( type1 == ev_entity ) && ( type2 == ev_object ) ) {
 	//	return true;
 	//}
 		
 	//if ( ( type2 == ev_entity ) && ( type1 == ev_object ) ) {
 	//	return true;
 	//}
 
 	return false;
 }
 
 /*
 ==============
 idCompiler::GetExpression
 ==============
 */
 idVarDef *idCompiler::GetExpression( int priority ) {
 	opcode_t		*op;
 	opcode_t		*oldop;
 	idVarDef		*e;
 	idVarDef		*e2;
 	const idVarDef	*oldtype;
 	etype_t 		type_a;
 	etype_t 		type_b;
 	etype_t 		type_c;
 	
 	if ( priority == 0 ) {
 		return GetTerm();
 	}
 		
 	e = GetExpression( priority - 1 );
 	if ( token == ";" ) {
 		// save us from searching through the opcodes unneccesarily
 		return e;
 	}
 
 	while( 1 ) {
 		if ( ( priority == FUNCTION_PRIORITY ) && CheckToken( "(" ) ) {
 			return ParseFunctionCall( e );
 		}
 
 		// has to be a punctuation
 		if ( immediateType ) {
 			break;
 		}
 
 		for( op = opcodes; op->name; op++ ) {
 			if ( ( op->priority == priority ) && CheckToken( op->name ) ) {
 				break;
 			}
 		}
 
 		if ( !op->name ) {
 			// next token isn't at this priority level
 			break;
 		}
 
 		// unary operators act only on the left operand
 		if ( op->type_b == &def_void ) {
 			e = EmitOpcode( op, e, 0 );
 			return e;
 		}
 
 		// preserve our base type
 		oldtype = basetype;
 
 		// field access needs scope from object
 		if ( ( op->name[ 0 ] == '.' ) && e->TypeDef()->Inherits( &type_object ) ) {
 			// save off what type this field is part of
 			basetype = e->TypeDef()->def;
 		}
 
 		if ( op->rightAssociative ) {
 			// if last statement is an indirect, change it to an address of
 			if ( gameLocal.program.NumStatements() > 0 ) {
 				statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
 				if ( ( statement.op >= OP_INDIRECT_F ) && ( statement.op < OP_ADDRESS ) ) {
 					statement.op = OP_ADDRESS;
 					type_pointer.SetPointerType( e->TypeDef() );
 					e->SetTypeDef( &type_pointer );
 				}
 			}
 
 			e2 = GetExpression( priority );
 		} else {
 			e2 = GetExpression( priority - 1 );
 		}
 
 		// restore type
 		basetype = oldtype;
 			
 		// type check
 		type_a = e->Type();
 		type_b = e2->Type();
 
 		// field access gets type from field
 		if ( op->name[ 0 ] == '.' ) {
 			if ( ( e2->Type() == ev_function ) && e2->TypeDef()->ReturnType() ) {
 				type_c = e2->TypeDef()->ReturnType()->Type();
 			} else if ( e2->TypeDef()->FieldType() ) {
 				type_c = e2->TypeDef()->FieldType()->Type();
 			} else {
 				// not a field
 				type_c = ev_error;
 			}
 		} else {
 			type_c = ev_void;
 		}
 
 		oldop = op;
 		while( !TypeMatches( type_a, op->type_a->Type() ) || !TypeMatches( type_b, op->type_b->Type() ) ||
 			( ( type_c != ev_void ) && !TypeMatches( type_c, op->type_c->Type() ) ) ) {
 			if ( ( op->priority == FUNCTION_PRIORITY ) && TypeMatches( type_a, op->type_a->Type() ) && TypeMatches( type_b, op->type_b->Type() ) ) {
 				break;
 			}
 
 			op++;
 			if ( !op->name || strcmp( op->name, oldop->name ) ) {
 				Error( "type mismatch for '%s'", oldop->name );
 			}
 		}
 
 		switch( op - opcodes ) {
 		case OP_SYSCALL :
 			ExpectToken( "(" );
 			e = ParseSysObjectCall( e2 );
 			break;
 
 		case OP_OBJECTCALL :
 			ExpectToken( "(" );
 			if ( ( e2->initialized != idVarDef::uninitialized ) && e2->value.functionPtr->eventdef ) {
 				e = ParseEventCall( e, e2 );
 			} else {
 				e = ParseObjectCall( e, e2 );
 			}
 			break;
 		
 		case OP_EVENTCALL :
 			ExpectToken( "(" );
 			if ( ( e2->initialized != idVarDef::uninitialized ) && e2->value.functionPtr->eventdef ) {
 				e = ParseEventCall( e, e2 );
 			} else {
 				e = ParseObjectCall( e, e2 );
 			}
 			break;
 
 		default:
 			if ( callthread ) {
 				Error( "Expecting function call after 'thread'" );
 			}
 
 			if ( ( type_a == ev_pointer ) && ( type_b != e->TypeDef()->PointerType()->Type() ) ) {
 				// FIXME: need to make a general case for this
 				if ( ( op - opcodes == OP_STOREP_F ) && ( e->TypeDef()->PointerType()->Type() == ev_boolean ) ) {
 					// copy from float to boolean pointer
 					op = &opcodes[ OP_STOREP_FTOBOOL ];
 				} else if ( ( op - opcodes == OP_STOREP_BOOL ) && ( e->TypeDef()->PointerType()->Type() == ev_float ) ) {
 					// copy from boolean to float pointer
 					op = &opcodes[ OP_STOREP_BOOLTOF ];
 				} else if ( ( op - opcodes == OP_STOREP_F ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
 					// copy from float to string pointer
 					op = &opcodes[ OP_STOREP_FTOS ];
 				} else if ( ( op - opcodes == OP_STOREP_BOOL ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
 					// copy from boolean to string pointer
 					op = &opcodes[ OP_STOREP_BTOS ];
 				} else if ( ( op - opcodes == OP_STOREP_V ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
 					// copy from vector to string pointer
 					op = &opcodes[ OP_STOREP_VTOS ];
 				} else if ( ( op - opcodes == OP_STOREP_ENT ) && ( e->TypeDef()->PointerType()->Type() == ev_object ) ) {
 					// store an entity into an object pointer
 					op = &opcodes[ OP_STOREP_OBJENT ];
 				} else {
 					Error( "type mismatch for '%s'", op->name );
 				}
 			}
 			
 			if ( op->rightAssociative ) {
 				e = EmitOpcode( op, e2, e );
 			} else {
 				e = EmitOpcode( op, e, e2 );
 			}
 
 			if ( op - opcodes == OP_STOREP_OBJENT ) {
 				// statement.b points to type_pointer, which is just a temporary that gets its type reassigned, so we store the real type in statement.c
 				// so that we can do a type check during run time since we don't know what type the script object is at compile time because it
 				// comes from an entity
 				statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
 				statement.c = type_pointer.PointerType()->def;
 			}
 
 			// field access gets type from field
 			if ( type_c != ev_void ) {
 				e->SetTypeDef( e2->TypeDef()->FieldType() );
 			}
 			break;
 		}
 	}
 
 	return e;
 }
 
 /*
 ================
 idCompiler::PatchLoop
 ================
 */
 void idCompiler::PatchLoop( int start, int continuePos ) {
 	int			i;
 	statement_t	*pos;
 
 	pos = &gameLocal.program.GetStatement( start );
 	for( i = start; i < gameLocal.program.NumStatements(); i++, pos++ ) {
 		if ( pos->op == OP_BREAK ) {
 			pos->op = OP_GOTO;
 			pos->a = JumpFrom( i );
 		} else if ( pos->op == OP_CONTINUE ) {
 			pos->op = OP_GOTO;
 			pos->a = JumpDef( i, continuePos );
 		}
 	}
 }
 
 /*
 ================
 idCompiler::ParseReturnStatement
 ================
 */
 void idCompiler::ParseReturnStatement() {
 	idVarDef	*e;
 	etype_t 	type_a;
 	etype_t 	type_b;
 	opcode_t	*op;
 
 	if ( CheckToken( ";" ) ) {
 		if ( scope->TypeDef()->ReturnType()->Type() != ev_void ) {
 			Error( "expecting return value" );
 		}
 
 		EmitOpcode( OP_RETURN, 0, 0 );
 		return;
 	}
 
 	e = GetExpression( TOP_PRIORITY );
 	ExpectToken( ";" );
 
 	type_a = e->Type();
 	type_b = scope->TypeDef()->ReturnType()->Type();
 
 	if ( TypeMatches( type_a, type_b ) ) {
 		EmitOpcode( OP_RETURN, e, 0 );
 		return;
 	}
 
 	for( op = opcodes; op->name; op++ ) {
 		if ( !strcmp( op->name, "=" ) ) {
 			break;
 		}
 	}
 
 	assert( op->name );
 
 	while( !TypeMatches( type_a, op->type_a->Type() ) || !TypeMatches( type_b, op->type_b->Type() ) ) {
 		op++;
 		if ( !op->name || strcmp( op->name, "=" ) ) {
 			Error( "type mismatch for return value" );
 		}
 	}
 
 	idTypeDef *returnType = scope->TypeDef()->ReturnType();
 	if ( returnType->Type() == ev_string ) {
 		EmitOpcode( op, e, gameLocal.program.returnStringDef );
 	} else {
 		gameLocal.program.returnDef->SetTypeDef( returnType );
 		EmitOpcode( op, e, gameLocal.program.returnDef );
 	}
 	EmitOpcode( OP_RETURN, 0, 0 );
 }
 	
 /*
 ================
 idCompiler::ParseWhileStatement
 ================
 */
 void idCompiler::ParseWhileStatement() {
 	idVarDef	*e;
 	int			patch1;
 	int			patch2;
 
 	loopDepth++;
 
 	ExpectToken( "(" );
 	
 	patch2 = gameLocal.program.NumStatements();
 	e = GetExpression( TOP_PRIORITY );
 	ExpectToken( ")" );
 
 	if ( ( e->initialized == idVarDef::initializedConstant ) && ( *e->value.intPtr != 0 ) ) {
 		//FIXME: we can completely skip generation of this code in the opposite case
 		ParseStatement();
 		EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
 	} else {
 		patch1 = gameLocal.program.NumStatements();
         EmitOpcode( OP_IFNOT, e, 0 );
 		ParseStatement();
 		EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
 		gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
 	}
 
 	// fixup breaks and continues
 	PatchLoop( patch2, patch2 );
 
 	loopDepth--;
 }
 
 /*
 ================
 idCompiler::ParseForStatement
 
 Form of for statement with a counter:
 
 	a = 0;
 start:					<< patch4
 	if ( !( a < 10 ) ) {
 		goto end;		<< patch1
 	} else {
 		goto process;	<< patch3
 	}
 
 increment:				<< patch2
 	a = a + 1;
 	goto start;			<< goto patch4
 
 process:
 	statements;
 	goto increment;		<< goto patch2
 
 end:
 
 Form of for statement without a counter:
 
 	a = 0;
 start:					<< patch2
 	if ( !( a < 10 ) ) {
 		goto end;		<< patch1
 	}
 
 process:
 	statements;
 	goto start;			<< goto patch2
 
 end:
 ================
 */
 void idCompiler::ParseForStatement() {
 	idVarDef	*e;
 	int			start;
 	int			patch1;
 	int			patch2;
 	int			patch3;
 	int			patch4;
 
 	loopDepth++;
 
 	start = gameLocal.program.NumStatements();
 
 	ExpectToken( "(" );
 	
 	// init
 	if ( !CheckToken( ";" ) ) {
 		do {
 			GetExpression( TOP_PRIORITY );
 		} while( CheckToken( "," ) );
 
 		ExpectToken( ";" );
 	}
 
 	// condition
 	patch2 = gameLocal.program.NumStatements();
 
 	e = GetExpression( TOP_PRIORITY );
 	ExpectToken( ";" );
 
 	//FIXME: add check for constant expression
 	patch1 = gameLocal.program.NumStatements();
 	EmitOpcode( OP_IFNOT, e, 0 );
 
 	// counter
 	if ( !CheckToken( ")" ) ) {
 		patch3 = gameLocal.program.NumStatements();
 		EmitOpcode( OP_IF, e, 0 );
 
 		patch4 = patch2;
 		patch2 = gameLocal.program.NumStatements();
 		do {
 			GetExpression( TOP_PRIORITY );
 		} while( CheckToken( "," ) );
 		
 		ExpectToken( ")" );
 
 		// goto patch4
 		EmitOpcode( OP_GOTO, JumpTo( patch4 ), 0 );
 
 		// fixup patch3
 		gameLocal.program.GetStatement( patch3 ).b = JumpFrom( patch3 );
 	}
 
 	ParseStatement();
 
 	// goto patch2
 	EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
 
 	// fixup patch1
 	gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
 
 	// fixup breaks and continues
 	PatchLoop( start, patch2 );
 
 	loopDepth--;
 }
 
 /*
 ================
 idCompiler::ParseDoWhileStatement
 ================
 */
 void idCompiler::ParseDoWhileStatement() {
 	idVarDef	*e;
 	int			patch1;
 
 	loopDepth++;
 
 	patch1 = gameLocal.program.NumStatements();
 	ParseStatement();
 	ExpectToken( "while" );
 	ExpectToken( "(" );
 	e = GetExpression( TOP_PRIORITY );
 	ExpectToken( ")" );
 	ExpectToken( ";" );
 
 	EmitOpcode( OP_IF, e, JumpTo( patch1 ) );
 
 	// fixup breaks and continues
 	PatchLoop( patch1, patch1 );
 
 	loopDepth--;
 }
 
 /*
 ================
 idCompiler::ParseIfStatement
 ================
 */
 void idCompiler::ParseIfStatement() {
 	idVarDef	*e;
 	int			patch1;
 	int			patch2;
 
 	ExpectToken( "(" );
 	e = GetExpression( TOP_PRIORITY );
 	ExpectToken( ")" );
 
 	//FIXME: add check for constant expression
 	patch1 = gameLocal.program.NumStatements();
 	EmitOpcode( OP_IFNOT, e, 0 );
 
 	ParseStatement();
 	
 	if ( CheckToken( "else" ) ) {
 		patch2 = gameLocal.program.NumStatements();
 		EmitOpcode( OP_GOTO, 0, 0 );
 		gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
 		ParseStatement();
 		gameLocal.program.GetStatement( patch2 ).a = JumpFrom( patch2 );
 	} else {
 		gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
 	}
 }
 
 /*
 ============
 idCompiler::ParseStatement
 ============
 */
 void idCompiler::ParseStatement() {
 	if ( CheckToken( ";" ) ) {
 		// skip semicolons, which are harmless and ok syntax
 		return;
 	}
 
 	if ( CheckToken( "{" ) ) {
 		do {
 			ParseStatement();
 		} while( !CheckToken( "}" ) );
 
 		return;
 	} 
 
 	if ( CheckToken( "return" ) ) {
 		ParseReturnStatement();
 		return;
 	}
 	
 	if ( CheckToken( "while" ) ) {
 		ParseWhileStatement();
 		return;
 	}
 
 	if ( CheckToken( "for" ) ) {
 		ParseForStatement();
 		return;
 	}
 
 	if ( CheckToken( "do" ) ) {
 		ParseDoWhileStatement();
 		return;
 	}
 
 	if ( CheckToken( "break" ) ) {
 		ExpectToken( ";" );
 		if ( !loopDepth ) {
 			Error( "cannot break outside of a loop" );
 		}
 		EmitOpcode( OP_BREAK, 0, 0 );
 		return;
 	}
 
 	if ( CheckToken( "continue" ) ) {
 		ExpectToken( ";" );
 		if ( !loopDepth ) {
 			Error( "cannot contine outside of a loop" );
 		}
 		EmitOpcode( OP_CONTINUE, 0, 0 );
 		return;
 	}
 
 	if ( CheckType() != NULL ) {
 		ParseDefs();
 		return;
 	}
 
 	if ( CheckToken( "if" ) ) {
 		ParseIfStatement();
 		return;
 	}
 
 	GetExpression( TOP_PRIORITY );
 	ExpectToken(";");
 }
 
 /*
 ================
 idCompiler::ParseObjectDef
 ================
 */
 void idCompiler::ParseObjectDef( const char *objname ) {
 	idTypeDef	*objtype;
 	idTypeDef	*type;
 	idTypeDef	*parentType;
 	idTypeDef	*fieldtype;
 	idStr		name;
 	const char  *fieldname;
 	idTypeDef	newtype( ev_field, NULL, "", 0, NULL );
 	idVarDef	*oldscope;
 	int			num;
 	int			i;
 
 	oldscope = scope;
 	if ( scope->Type() != ev_namespace ) {
 		Error( "Objects cannot be defined within functions or other objects" );
 	}
 
 	// make sure it doesn't exist before we create it
 	if ( gameLocal.program.FindType( objname ) != NULL ) {
 		Error( "'%s' : redefinition; different basic types", objname );
 	}
 
 	// base type
 	if ( !CheckToken( ":" ) ) {
 		parentType = &type_object;
 	} else {
 		parentType = ParseType();
 		if ( !parentType->Inherits( &type_object ) ) {
 			Error( "Objects may only inherit from objects." );
 		}
 	}
 	
 	objtype = gameLocal.program.AllocType( ev_object, NULL, objname, parentType == &type_object ? 0 : parentType->Size(), parentType );
 	objtype->def = gameLocal.program.AllocDef( objtype, objname, scope, true );
 	scope = objtype->def;
 
 	// inherit all the functions
 	num = parentType->NumFunctions();
 	for( i = 0; i < parentType->NumFunctions(); i++ ) {
 		const function_t *func = parentType->GetFunction( i );
 		objtype->AddFunction( func );
 	}
 
 	ExpectToken( "{" );
 
 	do {
 		if ( CheckToken( ";" ) ) {
 			// skip semicolons, which are harmless and ok syntax
 			continue;
 		}
 
 		fieldtype = ParseType();
 		newtype.SetFieldType( fieldtype );
 
 		fieldname = va( "%s field", fieldtype->Name() );
 		newtype.SetName( fieldname );
 
 		ParseName( name );
 
 		// check for a function prototype or declaraction
 		if ( CheckToken( "(" ) ) {
 			ParseFunctionDef( newtype.FieldType(), name );
 		} else {
 			type = gameLocal.program.GetType( newtype, true );
 			assert( !type->def );
 			gameLocal.program.AllocDef( type, name, scope, true );
 			objtype->AddField( type, name );
 			ExpectToken( ";" );
 		}
 	} while( !CheckToken( "}" ) );
 
 	scope = oldscope;
 
 	ExpectToken( ";" );
 }
 
 /*
 ============
 idCompiler::ParseFunction
 
 parse a function type
 ============
 */
 idTypeDef *idCompiler::ParseFunction( idTypeDef *returnType, const char *name ) {
 	idTypeDef	newtype( ev_function, NULL, name, type_function.Size(), returnType );
 	idTypeDef	*type;
 	
 	if ( scope->Type() != ev_namespace ) {
 		// create self pointer
 		newtype.AddFunctionParm( scope->TypeDef(), "self" );
 	}
 
 	if ( !CheckToken( ")" ) ) {
 		idStr parmName;
 		do {
 			type = ParseType();
 			ParseName( parmName );
 			newtype.AddFunctionParm( type, parmName );
 		} while( CheckToken( "," ) );
 
 		ExpectToken( ")" );
 	}
 
 	return gameLocal.program.GetType( newtype, true );
 }
 
 /*
 ================
 idCompiler::ParseFunctionDef
 ================
 */
 void idCompiler::ParseFunctionDef( idTypeDef *returnType, const char *name ) {
 	idTypeDef		*type;
 	idVarDef		*def;
 	const idVarDef	*parm;
 	idVarDef		*oldscope;
 	int 			i;
 	int 			numParms;
 	const idTypeDef	*parmType;
 	function_t		*func;
 	statement_t		*pos;
 
 	if ( ( scope->Type() != ev_namespace ) && !scope->TypeDef()->Inherits( &type_object ) ) {
 		Error( "Functions may not be defined within other functions" );
 	}
 
 	type = ParseFunction( returnType, name );
 	def = gameLocal.program.GetDef( type, name, scope );
 	if ( !def ) {
 		def = gameLocal.program.AllocDef( type, name, scope, true );
 		type->def = def;
 
 		func = &gameLocal.program.AllocFunction( def );
 		if ( scope->TypeDef()->Inherits( &type_object ) ) {
 			scope->TypeDef()->AddFunction( func );
 		}
 	} else {
 		func = def->value.functionPtr;
 		assert( func );
 		if ( func->firstStatement ) {
 			Error( "%s redeclared", def->GlobalName() );
 		}
 	}
 
 	// check if this is a prototype or declaration
 	if ( !CheckToken( "{" ) ) {
 		// it's just a prototype, so get the ; and move on
 		ExpectToken( ";" );
 		return;
 	}
 
 	// calculate stack space used by parms
 	numParms = type->NumParameters();
 	func->parmSize.SetNum( numParms );
 	for( i = 0; i < numParms; i++ ) {
 		parmType = type->GetParmType( i );
 		if ( parmType->Inherits( &type_object ) ) {
 			func->parmSize[ i ] = type_object.Size();
 		} else {
 			func->parmSize[ i ] = parmType->Size();
 		}
 		func->parmTotal += func->parmSize[ i ];
 	}
 
 	// define the parms
 	for( i = 0; i < numParms; i++ ) {
 		if ( gameLocal.program.GetDef( type->GetParmType( i ), type->GetParmName( i ), def ) ) {
 			Error( "'%s' defined more than once in function parameters", type->GetParmName( i ) );
 		}
 		parm = gameLocal.program.AllocDef( type->GetParmType( i ), type->GetParmName( i ), def, false );
 	}
 
 	oldscope = scope;
 	scope = def;
 
 	func->firstStatement = gameLocal.program.NumStatements();
 
 	// check if we should call the super class constructor
 	if ( oldscope->TypeDef()->Inherits( &type_object ) && !idStr::Icmp( name, "init" ) ) {
 		idTypeDef *superClass;
 		function_t *constructorFunc = NULL;
 
 		// find the superclass constructor
 		for( superClass = oldscope->TypeDef()->SuperClass(); superClass != &type_object; superClass = superClass->SuperClass() ) {
 			constructorFunc = gameLocal.program.FindFunction( va( "%s::init", superClass->Name() ) );
 			if ( constructorFunc ) {
 				break;
 			}
 		}
 
 		// emit the call to the constructor
 		if ( constructorFunc ) {
 			idVarDef *selfDef = gameLocal.program.GetDef( type->GetParmType( 0 ), type->GetParmName( 0 ), def );
 			assert( selfDef );
 			EmitPush( selfDef, selfDef->TypeDef() );
 			EmitOpcode( &opcodes[ OP_CALL ], constructorFunc->def, 0 );
 		}
 	}
 
 	// parse regular statements
 	while( !CheckToken( "}" ) ) {
 		ParseStatement();
 	}
 
 	// check if we should call the super class destructor
 	if ( oldscope->TypeDef()->Inherits( &type_object ) && !idStr::Icmp( name, "destroy" ) ) {
 		idTypeDef *superClass;
 		function_t *destructorFunc = NULL;
 
 		// find the superclass destructor
 		for( superClass = oldscope->TypeDef()->SuperClass(); superClass != &type_object; superClass = superClass->SuperClass() ) {
 			destructorFunc = gameLocal.program.FindFunction( va( "%s::destroy", superClass->Name() ) );
 			if ( destructorFunc ) {
 				break;
 			}
 		}
 
 		if ( destructorFunc ) {
 			if ( func->firstStatement < gameLocal.program.NumStatements() ) {
 				// change all returns to point to the call to the destructor
 				pos = &gameLocal.program.GetStatement( func->firstStatement );
 				for( i = func->firstStatement; i < gameLocal.program.NumStatements(); i++, pos++ ) {
 					if ( pos->op == OP_RETURN ) {
 						pos->op = OP_GOTO;
 						pos->a = JumpDef( i, gameLocal.program.NumStatements() );
 					}
 				}
 			}
 
 			// emit the call to the destructor
 			idVarDef *selfDef = gameLocal.program.GetDef( type->GetParmType( 0 ), type->GetParmName( 0 ), def );
 			assert( selfDef );
 			EmitPush( selfDef, selfDef->TypeDef() );
 			EmitOpcode( &opcodes[ OP_CALL ], destructorFunc->def, 0 );
 		}
 	}
 
 // Disabled code since it caused a function to fall through to the next function when last statement is in the form "if ( x ) { return; }"
 #if 0
 	// don't bother adding a return opcode if the "return" statement was used.
 	if ( ( func->firstStatement == gameLocal.program.NumStatements() ) || ( gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 ).op != OP_RETURN ) ) {
 		// emit an end of statements opcode
 		EmitOpcode( OP_RETURN, 0, 0 );
 	}
 #else
 	// always emit the return opcode
 	EmitOpcode( OP_RETURN, 0, 0 );
 #endif
 
 	// record the number of statements in the function
 	func->numStatements = gameLocal.program.NumStatements() - func->firstStatement;
 
 	scope = oldscope;
 }
 
 /*
 ================
 idCompiler::ParseVariableDef
 ================
 */
 void idCompiler::ParseVariableDef( idTypeDef *type, const char *name ) {
 	idVarDef	*def, *def2;
 	bool		negate;
 
 	def = gameLocal.program.GetDef( type, name, scope );
 	if ( def ) {
 		Error( "%s redeclared", name );
 	}
 	
 	def = gameLocal.program.AllocDef( type, name, scope, false );
 
 	// check for an initialization
 	if ( CheckToken( "=" ) ) {
 		// if a local variable in a function then write out interpreter code to initialize variable
 		if ( scope->Type() == ev_function ) {
 			def2 = GetExpression( TOP_PRIORITY );
 			if ( ( type == &type_float ) && ( def2->TypeDef() == &type_float ) ) {
 				EmitOpcode( OP_STORE_F, def2, def );
 			} else if ( ( type == &type_vector ) && ( def2->TypeDef() == &type_vector ) ) {
 				EmitOpcode( OP_STORE_V, def2, def );
 			} else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_string ) ) {
 				EmitOpcode( OP_STORE_S, def2, def );
 			} else if ( ( type == &type_entity ) && ( ( def2->TypeDef() == &type_entity ) || ( def2->TypeDef()->Inherits( &type_object ) ) ) ) {
 				EmitOpcode( OP_STORE_ENT, def2, def );
 			} else if ( ( type->Inherits( &type_object ) ) && ( def2->TypeDef() == &type_entity ) ) {
 				EmitOpcode( OP_STORE_OBJENT, def2, def );
 			} else if ( ( type->Inherits( &type_object ) ) && ( def2->TypeDef()->Inherits( type ) ) ) {
 				EmitOpcode( OP_STORE_OBJ, def2, def );
 			} else if ( ( type == &type_boolean ) && ( def2->TypeDef() == &type_boolean ) ) {
 				EmitOpcode( OP_STORE_BOOL, def2, def );
 			} else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_float ) ) {
 				EmitOpcode( OP_STORE_FTOS, def2, def );
 			} else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_boolean ) ) {
 				EmitOpcode( OP_STORE_BTOS, def2, def );
 			} else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_vector ) ) {
 				EmitOpcode( OP_STORE_VTOS, def2, def );
 			} else if ( ( type == &type_boolean ) && ( def2->TypeDef() == &type_float ) ) {
 				EmitOpcode( OP_STORE_FTOBOOL, def2, def );
 			} else if ( ( type == &type_float ) && ( def2->TypeDef() == &type_boolean ) ) {
 				EmitOpcode( OP_STORE_BOOLTOF, def2, def );
 			} else {
 				Error( "bad initialization for '%s'", name );
 			}
 		} else {
 			// global variables can only be initialized with immediate values
 			negate = false;
 			if ( token.type == TT_PUNCTUATION && token == "-" ) {
 				negate = true;
 				NextToken();
 				if ( immediateType != &type_float ) {
 					Error( "wrong immediate type for '-' on variable '%s'", name );
 				}
 			}
 
 			if ( immediateType != type ) {
 				Error( "wrong immediate type for '%s'", name );
 			}
 
 			// global variables are initialized at start up
 			if ( type == &type_string ) {
 				def->SetString( token, false );
 			} else {
 				if ( negate ) {
 					immediate._float = -immediate._float;
 				}
 				def->SetValue( immediate, false );
 			}
 			NextToken();
 		}
 	} else if ( type == &type_string ) {
 		// local strings on the stack are initialized in the interpreter
 		if ( scope->Type() != ev_function ) {
 			def->SetString( "", false );
 		}
 	} else if ( type->Inherits( &type_object ) ) {
 		if ( scope->Type() != ev_function ) {
 			def->SetObject( NULL );
 		}
 	}
 }
 
 /*
 ================
 idCompiler::GetTypeForEventArg
 ================
 */
 idTypeDef *idCompiler::GetTypeForEventArg( char argType ) {
 	idTypeDef *type;
 
 	switch( argType ) {
 	case D_EVENT_INTEGER :
 		// this will get converted to int by the interpreter
 		type = &type_float;
 		break;
 
 	case D_EVENT_FLOAT :
 		type = &type_float;
 		break;
 
 	case D_EVENT_VECTOR :
 		type = &type_vector;
 		break;
 
 	case D_EVENT_STRING :
 		type = &type_string;
 		break;
 
 	case D_EVENT_ENTITY :
 	case D_EVENT_ENTITY_NULL :
 		type = &type_entity;
 		break;
 
 	case D_EVENT_VOID :
 		type = &type_void;
 		break;
 
 	case D_EVENT_TRACE :
 		// This data type isn't available from script
 		type = NULL;
 		break;
 
 	default:
 		// probably a typo
 		type = NULL;
 		break;
 	}
 	
 	return type;
 }
 
 /*
 ================
 idCompiler::ParseEventDef
 ================
 */
 void idCompiler::ParseEventDef( idTypeDef *returnType, const char *name ) {
 	const idTypeDef	*expectedType;
 	idTypeDef		*argType;
 	idTypeDef		*type;
 	int 			i;
 	int				num;
 	const char		*format;
 	const idEventDef *ev;
 	idStr			parmName;
 
 	ev = idEventDef::FindEvent( name );
 	if ( ev == NULL ) {
 		Error( "Unknown event '%s'", name );
 		return;
 	}
 
 	// set the return type
 	expectedType = GetTypeForEventArg( ev->GetReturnType() );
 	if ( expectedType == NULL ) {
 		Error( "Invalid return type '%c' in definition of '%s' event.", ev->GetReturnType(), name );
 		return;
 	}
 	if ( returnType != expectedType ) {
 		Error( "Return type doesn't match internal return type '%s'", expectedType->Name() );
 	}
 
 	idTypeDef newtype( ev_function, NULL, name, type_function.Size(), returnType );
 
 	ExpectToken( "(" );
 
 	format = ev->GetArgFormat();
 	num = strlen( format );
 	for( i = 0; i < num; i++ ) {
 		expectedType = GetTypeForEventArg( format[ i ] );
 		if ( expectedType == NULL || ( expectedType == &type_void ) ) {
 			Error( "Invalid parameter '%c' in definition of '%s' event.", format[ i ], name );
 			return;
 		}
 
 		argType = ParseType();
 		ParseName( parmName );
 		if ( argType != expectedType ) {
 			Error( "The type of parm %d ('%s') does not match the internal type '%s' in definition of '%s' event.", 
 				i + 1, parmName.c_str(), expectedType->Name(), name );
 		}
 
 		newtype.AddFunctionParm( argType, "" );
 
 		if ( i < num - 1 ) {
 			if ( CheckToken( ")" ) ) {
 				Error( "Too few parameters for event definition.  Internal definition has %d parameters.", num );
 			}
 			ExpectToken( "," );
 		}
 	}
 	if ( !CheckToken( ")" ) ) {
 		Error( "Too many parameters for event definition.  Internal definition has %d parameters.", num );
 	}
 	ExpectToken( ";" );
 
 	type = gameLocal.program.FindType( name );
 	if ( type ) {
 		if ( !newtype.MatchesType( *type ) || ( type->def->value.functionPtr->eventdef != ev ) ) {
 			Error( "Type mismatch on redefinition of '%s'", name );
 		}
 	} else {
 		type = gameLocal.program.AllocType( newtype );
 		type->def = gameLocal.program.AllocDef( type, name, &def_namespace, true );
 
 		function_t &func	= gameLocal.program.AllocFunction( type->def );
 		func.eventdef		= ev;
 		func.parmSize.SetNum( num );
 		for( i = 0; i < num; i++ ) {
 			argType = newtype.GetParmType( i );
 			func.parmTotal		+= argType->Size();
 			func.parmSize[ i ]	= argType->Size();
 		}
 
 		// mark the parms as local
 		func.locals	= func.parmTotal;
 	}
 }
 
 /*
 ================
 idCompiler::ParseDefs
 
 Called at the outer layer and when a local statement is hit
 ================
 */
 void idCompiler::ParseDefs() {
 	idStr 		name;
 	idTypeDef	*type;
 	idVarDef	*def;
 	idVarDef	*oldscope;
 
 	if ( CheckToken( ";" ) ) {
 		// skip semicolons, which are harmless and ok syntax
 		return;
 	}
 
 	type = ParseType();
 	if ( type == &type_scriptevent ) {
 		type = ParseType();
 		ParseName( name );
 		ParseEventDef( type, name );
 		return;
 	}
     
 	ParseName( name );
 
 	if ( type == &type_namespace ) {
 		def = gameLocal.program.GetDef( type, name, scope );
 		if ( !def ) {
 			def = gameLocal.program.AllocDef( type, name, scope, true );
 		}
 		ParseNamespace( def );
 	} else if ( CheckToken( "::" ) ) {
 		def = gameLocal.program.GetDef( NULL, name, scope );
 		if ( !def ) {
 			Error( "Unknown object name '%s'", name.c_str() );
 		}
 		ParseName( name );
 		oldscope = scope;
 		scope = def;
 
 		ExpectToken( "(" );
 		ParseFunctionDef( type, name.c_str() );
 		scope = oldscope;
 	} else if ( type == &type_object ) {
 		ParseObjectDef( name.c_str() );
 	} else if ( CheckToken( "(" ) ) {		// check for a function prototype or declaraction
 		ParseFunctionDef( type, name.c_str() );
 	} else {
 		ParseVariableDef( type, name.c_str() );
 		while( CheckToken( "," ) ) {
 			ParseName( name );
 			ParseVariableDef( type, name.c_str() );
 		}
 		ExpectToken( ";" );
 	}
 }
 
 /*
 ================
 idCompiler::ParseNamespace
 
 Parses anything within a namespace definition
 ================
 */
 void idCompiler::ParseNamespace( idVarDef *newScope ) {
 	idVarDef *oldscope;
 
 	oldscope = scope;
 	if ( newScope != &def_namespace ) {
 		ExpectToken( "{" );
 	}
 
 	while( !eof ) {
 		scope		= newScope;
 		callthread	= false;
 
 		if ( ( newScope != &def_namespace ) && CheckToken( "}" ) ) {
 			break;
 		}
 
 		ParseDefs();
 	}
 
 	scope = oldscope;
 }
 
 /*
 ============
 idCompiler::CompileFile
 
 compiles the 0 terminated text, adding definitions to the program structure
 ============
 */
 void idCompiler::CompileFile( const char *text, const char *filename, bool toConsole ) {
 	idTimer compile_time;
 	bool error;
 
 	compile_time.Start();
 
 	scope				= &def_namespace;
 	basetype			= NULL;
 	callthread			= false;
 	loopDepth			= 0;
 	eof					= false;
 	braceDepth			= 0;
 	immediateType		= NULL;
 	currentLineNumber	= 0;
 	console				= toConsole;
 	
 	memset( &immediate, 0, sizeof( immediate ) );
 
 	parser.SetFlags( LEXFL_ALLOWMULTICHARLITERALS );
 	parser.LoadMemory( text, strlen( text ), filename );
 	parserPtr = &parser;
 
 	// unread tokens to include script defines
 	token = SCRIPT_DEFAULTDEFS;
 	token.type = TT_STRING;
 	token.subtype = token.Length();
 	token.line = token.linesCrossed = 0;
 	parser.UnreadToken( &token );
 
 	token = "include";
 	token.type = TT_NAME;
 	token.subtype = token.Length();
 	token.line = token.linesCrossed = 0;
 	parser.UnreadToken( &token );
 
 	token = "#";
 	token.type = TT_PUNCTUATION;
 	token.subtype = P_PRECOMP;
 	token.line = token.linesCrossed = 0;
 	parser.UnreadToken( &token );
 
 	// init the current token line to be the first line so that currentLineNumber is set correctly in NextToken
 	token.line = 1;
 
 	error = false;
 	try {
 		// read first token
 		NextToken();
 		while( !eof && !error ) {
 			// parse from global namespace
 			ParseNamespace( &def_namespace );
 		}
 	}
 		
 	catch( idCompileError &err ) {
 		idStr error;
 
 		if ( console ) {
 			// don't print line number of an error if were calling script from the console using the "script" command
 			sprintf( error, "Error: %s\n", err.GetError() );
 		} else {
 			sprintf( error, "Error: file %s, line %d: %s\n", gameLocal.program.GetFilename( currentFileNumber ), currentLineNumber, err.GetError() );
 		}
 
 		parser.FreeSource();
 
 		throw idCompileError( error );
 	}
 
 	parser.FreeSource();
 
 	compile_time.Stop();
 	if ( !toConsole ) {
 		gameLocal.Printf( "Compiled '%s': %.1f ms\n", filename, compile_time.Milliseconds() );
 	}
 }