id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-12-02 17:02:17 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/neo/d3xp/script/Script_Compiler.cpp

3263 lines
74 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
Copyright (C) 2012 Robert Beckebans
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 "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 ];
// RB begin
const char* idCompiler::punctuation[] =
{
// RB end
"+=", "-=", "*=", "/=", "%=", "&=", "|=", "++", "--",
"&&", "||", "<=", ">=", "==", "!=", "::", ";", ",",
"~", "!", "*", "/", "%", "(", ")", "-", "+",
"=", "[", "]", ".", "<", ">" , "&", "|", ":", NULL
};
// RB: added const
const opcode_t idCompiler::opcodes[] =
{
// RB end
{ "<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()
{
// RB begin
const char** ptr;
// RB end
int id;
// make sure we have the right # of opcodes in the table
assert( ( sizeof( opcodes ) / sizeof( opcodes[ 0 ] ) ) == ( NUM_OPCODES + 1 ) );
eof = true;
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 );
#if defined(USE_EXCEPTIONS)
throw idCompileError( string );
#else
parserPtr->Error( "%s", string );
#endif
}
/*
============
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 0;
}
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 )
{
// RB: added const
const opcode_t* op;
const opcode_t* out;
// RB end
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;
// RB: added const
const opcode_t* op;
// RB end
// 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 )
{
// RB: added const
const opcode_t* op;
const opcode_t* oldop;
// RB end
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;
// RB: added const
const opcode_t* op;
// RB end
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;
#if defined(USE_EXCEPTIONS)
try
#endif
{
// read first token
NextToken();
while( !eof && !error )
{
// parse from global namespace
ParseNamespace( &def_namespace );
}
}
#if defined(USE_EXCEPTIONS)
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 );
}
#else
// FIXME check for errors
if( error )
{
common->Printf( "Error: idCompiler::CompileFile: file %s, line %d: unknown error\n", gameLocal.program.GetFilename( currentFileNumber ), currentLineNumber );
}
#endif
parser.FreeSource();
compile_time.Stop();
if( !toConsole )
{
gameLocal.Printf( "Compiled '%s': %.1f ms\n", filename, compile_time.Milliseconds() );
}
}
Reference in a new issue View git blame Copy permalink