3608 lines
80 KiB
C++
3608 lines
80 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
#include "../precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
//#define DEBUG_EVAL
|
|
#define MAX_DEFINEPARMS 128
|
|
#define DEFINEHASHSIZE 2048
|
|
|
|
#define TOKEN_FL_RECURSIVE_DEFINE 1
|
|
|
|
define_t * idParser::globaldefines;
|
|
|
|
/*
|
|
================
|
|
idParser::SetBaseFolder
|
|
================
|
|
*/
|
|
void idParser::SetBaseFolder( const char *path ) {
|
|
idLexer::SetBaseFolder( path );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddGlobalDefine
|
|
================
|
|
*/
|
|
int idParser::AddGlobalDefine( const char *string ) {
|
|
define_t *define;
|
|
|
|
define = DefineFromString( string );
|
|
if ( define == NULL ) {
|
|
return false;
|
|
}
|
|
define->next = globaldefines;
|
|
globaldefines = define;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::RemoveGlobalDefine
|
|
================
|
|
*/
|
|
int idParser::RemoveGlobalDefine( const char *name ) {
|
|
define_t *d, *prev;
|
|
|
|
for ( prev = NULL, d = idParser::globaldefines; d != NULL; prev = d, d = d->next ) {
|
|
if ( !idStr::Cmp( d->name, name ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( d != NULL ) {
|
|
if ( prev != NULL ) {
|
|
prev->next = d->next;
|
|
} else {
|
|
globaldefines = d->next;
|
|
}
|
|
FreeDefine( d );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::RemoveAllGlobalDefines
|
|
================
|
|
*/
|
|
void idParser::RemoveAllGlobalDefines( void ) {
|
|
define_t *define;
|
|
|
|
for ( define = globaldefines; define != NULL; define = globaldefines ) {
|
|
globaldefines = globaldefines->next;
|
|
FreeDefine(define);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idParser
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
================
|
|
idParser::PrintDefine
|
|
================
|
|
*/
|
|
void idParser::PrintDefine( define_t *define ) {
|
|
idLib::common->Printf( "define->name = %s\n", define->name );
|
|
idLib::common->Printf( "define->flags = %d\n", define->flags );
|
|
idLib::common->Printf( "define->builtin = %d\n", define->builtin );
|
|
idLib::common->Printf( "define->numparms = %d\n", define->numparms );
|
|
}
|
|
|
|
/*
|
|
================
|
|
PC_NameHash
|
|
================
|
|
*/
|
|
ID_INLINE int PC_NameHash( const char *name ) {
|
|
int hash, i;
|
|
|
|
hash = 0;
|
|
for ( i = 0; name[i] != '\0'; i++ ) {
|
|
hash += name[i] * (119 + i);
|
|
}
|
|
hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (DEFINEHASHSIZE-1);
|
|
return hash;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddDefineToHash
|
|
================
|
|
*/
|
|
void idParser::AddDefineToHash( define_t *define, define_t **definehash ) {
|
|
int hash;
|
|
|
|
hash = PC_NameHash( define->name );
|
|
define->hashnext = definehash[hash];
|
|
definehash[hash] = define;
|
|
}
|
|
|
|
/*
|
|
================
|
|
FindHashedDefine
|
|
================
|
|
*/
|
|
define_t *idParser::FindHashedDefine( define_t **definehash, const char *name ) {
|
|
define_t *d;
|
|
int hash;
|
|
|
|
hash = PC_NameHash(name);
|
|
for ( d = definehash[hash]; d != NULL; d = d->hashnext ) {
|
|
if ( !idStr::Cmp( d->name, name ) ) {
|
|
return d;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::FindDefine
|
|
================
|
|
*/
|
|
define_t *idParser::FindDefine( define_t *defines, const char *name ) {
|
|
define_t *d;
|
|
|
|
for ( d = defines; d != NULL; d = d->next ) {
|
|
if ( !idStr::Cmp( d->name, name ) ) {
|
|
return d;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::FindDefineParm
|
|
================
|
|
*/
|
|
int idParser::FindDefineParm( define_t *define, const char *name ) {
|
|
idToken *p;
|
|
int i;
|
|
|
|
i = 0;
|
|
for ( p = define->parms; p != NULL; p = p->next ) {
|
|
if ( (*p) == name ) {
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::CopyDefine
|
|
================
|
|
*/
|
|
define_t *idParser::CopyDefine( define_t *define ) {
|
|
int nameLength;
|
|
define_t *newdefine;
|
|
idToken *token, *newtoken, *lasttoken;
|
|
|
|
nameLength = idStr::Length( define->name ) + 1;
|
|
newdefine = (define_t *) Mem_Alloc( sizeof(define_t) + nameLength );
|
|
// copy the define name
|
|
newdefine->name = (char *) newdefine + sizeof(define_t);
|
|
idStr::Copynz( newdefine->name, define->name, nameLength );
|
|
newdefine->flags = define->flags;
|
|
newdefine->builtin = define->builtin;
|
|
newdefine->numparms = define->numparms;
|
|
// the define is not linked
|
|
newdefine->next = NULL;
|
|
newdefine->hashnext = NULL;
|
|
// copy the define tokens
|
|
newdefine->tokens = NULL;
|
|
for ( lasttoken = NULL, token = define->tokens; token != NULL; token = token->next ) {
|
|
newtoken = new idToken( *token );
|
|
newtoken->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = newtoken;
|
|
} else {
|
|
newdefine->tokens = newtoken;
|
|
}
|
|
lasttoken = newtoken;
|
|
}
|
|
// copy the define parameters
|
|
newdefine->parms = NULL;
|
|
for ( lasttoken = NULL, token = define->parms; token; token = token->next ) {
|
|
newtoken = new idToken( *token );
|
|
newtoken->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = newtoken;
|
|
} else {
|
|
newdefine->parms = newtoken;
|
|
}
|
|
lasttoken = newtoken;
|
|
}
|
|
return newdefine;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::FreeDefine
|
|
================
|
|
*/
|
|
void idParser::FreeDefine( define_t *define ) {
|
|
idToken *t, *next;
|
|
|
|
// free the define parameters
|
|
for ( t = define->parms; t != NULL; t = next ) {
|
|
next = t->next;
|
|
delete t;
|
|
}
|
|
// free the define tokens
|
|
for ( t = define->tokens; t != NULL; t = next ) {
|
|
next = t->next;
|
|
delete t;
|
|
}
|
|
// free the define
|
|
Mem_Free( define );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DefineFromString
|
|
================
|
|
*/
|
|
define_t *idParser::DefineFromString( const char *string ) {
|
|
idParser src;
|
|
define_t *def;
|
|
|
|
if ( !src.LoadMemory( string, idStr::Length( string ), "*defineString" ) ) {
|
|
return NULL;
|
|
}
|
|
// create a define from the source
|
|
if ( !src.Directive_define( false ) ) {
|
|
src.FreeSource();
|
|
return NULL;
|
|
}
|
|
def = src.CopyFirstDefine();
|
|
src.FreeSource();
|
|
// if the define was created succesfully
|
|
return def;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Error
|
|
================
|
|
*/
|
|
void idParser::Error( const char *str, ... ) const {
|
|
char text[MAX_STRING_CHARS];
|
|
va_list ap;
|
|
|
|
va_start( ap, str );
|
|
vsprintf( text, str, ap );
|
|
va_end( ap );
|
|
if ( scriptstack != NULL ) {
|
|
scriptstack->Error( text );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Warning
|
|
================
|
|
*/
|
|
void idParser::Warning( const char *str, ... ) const {
|
|
char text[MAX_STRING_CHARS];
|
|
va_list ap;
|
|
|
|
va_start( ap, str );
|
|
vsprintf( text, str, ap );
|
|
va_end( ap );
|
|
if ( scriptstack != NULL ) {
|
|
scriptstack->Warning( text );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::PushIndent
|
|
================
|
|
*/
|
|
void idParser::PushIndent( int type, int skip, int skipElse ) {
|
|
indent_t *indent;
|
|
|
|
indent = (indent_t *) Mem_Alloc( sizeof( indent_t ) );
|
|
indent->type = type;
|
|
indent->script = this->scriptstack;
|
|
indent->skip = ( skip != 0 );
|
|
indent->skipElse = ( skipElse != 0 );
|
|
this->skip += indent->skip;
|
|
indent->next = this->indentstack;
|
|
this->indentstack = indent;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::PopIndent
|
|
================
|
|
*/
|
|
void idParser::PopIndent( int &type, int &skip, int &skipElse ) {
|
|
indent_t *indent;
|
|
|
|
type = 0;
|
|
skip = 0;
|
|
|
|
indent = this->indentstack;
|
|
if ( !indent ) {
|
|
return;
|
|
}
|
|
|
|
// must be an indent from the current script
|
|
if ( this->indentstack->script != this->scriptstack ) {
|
|
return;
|
|
}
|
|
|
|
type = indent->type;
|
|
skip = indent->skip;
|
|
skipElse = indent->skipElse;
|
|
this->indentstack = this->indentstack->next;
|
|
this->skip -= indent->skip;
|
|
Mem_Free( indent );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::PushScript
|
|
================
|
|
*/
|
|
bool idParser::PushScript( idLexer *script ) {
|
|
idLexer *s;
|
|
|
|
for ( s = scriptstack; s != NULL; s = s->next ) {
|
|
if ( !idStr::Icmp( s->GetFileName(), script->GetFileName() ) ) {
|
|
//Warning( "'%s' recursively included", script->GetFileName() );
|
|
return false;
|
|
}
|
|
}
|
|
//push the script on the script stack
|
|
script->next = scriptstack;
|
|
scriptstack = script;
|
|
|
|
// add dependency
|
|
if ( OSPath ) {
|
|
const char* relativePath = idLib::fileSystem->OSPathToRelativePath( script->GetFileName() );
|
|
if ( relativePath == NULL || relativePath[0] == '\0' ) {
|
|
dependencies.AddUnique( script->GetFileName() );
|
|
} else {
|
|
dependencies.AddUnique( relativePath );
|
|
}
|
|
} else {
|
|
dependencies.AddUnique( script->GetFileName() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idParser::PushDependencies
|
|
============
|
|
*/
|
|
void idParser::PushDependencies() {
|
|
dependencyStateStack.Push( dependencies.Num() );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idParser::PopDependencies
|
|
============
|
|
*/
|
|
void idParser::PopDependencies() {
|
|
if( dependencyStateStack.Empty() ) {
|
|
idLib::common->Error( "idParser::PopDependencies: stack underflow" );
|
|
}
|
|
int num = GetCurrentDependency();
|
|
dependencies.SetNum( num );
|
|
dependencyStateStack.Pop();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idParser::GetNextDependency
|
|
============
|
|
*/
|
|
const char* idParser::GetNextDependency( int& index ) const {
|
|
if( index < 0 || index >= dependencies.Num() ) {
|
|
return NULL;
|
|
}
|
|
return dependencies[ index++ ];
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idParser::GetCurrentDependency
|
|
============
|
|
*/
|
|
int idParser::GetCurrentDependency( void ) const {
|
|
return dependencyStateStack.Top();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadSourceToken
|
|
================
|
|
*/
|
|
int idParser::ReadSourceToken( idToken *token ) {
|
|
idToken *t;
|
|
idLexer *script;
|
|
int type, skip, skipElse, changedScript;
|
|
|
|
if ( scriptstack == NULL ) {
|
|
idLib::common->FatalError( "idParser::ReadSourceToken: not loaded" );
|
|
return false;
|
|
}
|
|
changedScript = 0;
|
|
// if there's no token already available
|
|
while( tokens == NULL ) {
|
|
// if there's a token to read from the script
|
|
if ( scriptstack->ReadToken( token ) ) {
|
|
token->linesCrossed += changedScript;
|
|
return true;
|
|
}
|
|
// if at the end of the script
|
|
if ( scriptstack->EndOfFile() ) {
|
|
// remove all indents of the script
|
|
while( this->indentstack != NULL && this->indentstack->script == this->scriptstack ) {
|
|
Warning( "missing #endif" );
|
|
PopIndent( type, skip, skipElse );
|
|
}
|
|
changedScript = 1;
|
|
}
|
|
// if this was the initial script
|
|
if ( scriptstack->next == NULL ) {
|
|
return false;
|
|
}
|
|
// remove the script and return to the previous one
|
|
script = scriptstack;
|
|
scriptstack = scriptstack->next;
|
|
delete script;
|
|
}
|
|
// copy the already available token
|
|
*token = *tokens;
|
|
// remove the token from the source
|
|
t = tokens;
|
|
tokens = tokens->next;
|
|
delete t;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::UnreadSourceToken
|
|
================
|
|
*/
|
|
bool idParser::UnreadSourceToken( const idToken& token ) {
|
|
idToken* t = new idToken( token );
|
|
t->next = tokens;
|
|
tokens = t;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadDefineParms
|
|
================
|
|
*/
|
|
int idParser::ReadDefineParms( define_t *define, idToken **parms, int maxparms ) {
|
|
define_t *newdefine;
|
|
idToken token, *t, *last;
|
|
int i, done, lastcomma, numparms, indent;
|
|
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "define '%s' missing parameters", define->name );
|
|
return false;
|
|
}
|
|
|
|
if ( define->numparms > maxparms ) {
|
|
Error( "define with more than %d parameters", maxparms );
|
|
return false;
|
|
}
|
|
|
|
for ( i = 0; i < define->numparms; i++ ) {
|
|
parms[i] = NULL;
|
|
}
|
|
// if no leading "("
|
|
if ( token != "(" ) {
|
|
UnreadSourceToken( token );
|
|
Error( "define '%s' missing parameters", define->name );
|
|
return false;
|
|
}
|
|
// read the define parameters
|
|
for ( done = 0, numparms = 0, indent = 1; !done; ) {
|
|
if ( numparms >= maxparms ) {
|
|
Error( "define '%s' with too many parameters", define->name );
|
|
return false;
|
|
}
|
|
parms[numparms] = NULL;
|
|
lastcomma = 1;
|
|
last = NULL;
|
|
while( !done ) {
|
|
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "define '%s' incomplete", define->name );
|
|
return false;
|
|
}
|
|
|
|
if ( token == "," ) {
|
|
if ( indent <= 1 ) {
|
|
if ( lastcomma ) {
|
|
Error( "define '%s' has too many commas", define->name );
|
|
}
|
|
if ( numparms >= define->numparms ) {
|
|
Error( "define '%s' has too many define parameters", define->name );
|
|
}
|
|
lastcomma = 1;
|
|
break;
|
|
}
|
|
} else if ( token == "(" ) {
|
|
indent++;
|
|
} else if ( token == ")" ) {
|
|
indent--;
|
|
if ( indent <= 0 ) {
|
|
if ( !parms[define->numparms-1] ) {
|
|
Error( "define '%s' has too few define parameters", define->name );
|
|
}
|
|
done = 1;
|
|
break;
|
|
}
|
|
} else if ( token.type == TT_NAME ) {
|
|
newdefine = FindHashedDefine( definehash, token.c_str() );
|
|
if ( newdefine ) {
|
|
if ( !ExpandDefineIntoSource( &token, newdefine ) ) {
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
lastcomma = 0;
|
|
|
|
if ( numparms < define->numparms ) {
|
|
t = new idToken( token );
|
|
t->next = NULL;
|
|
if ( last != NULL ) {
|
|
last->next = t;
|
|
} else {
|
|
parms[numparms] = t;
|
|
}
|
|
last = t;
|
|
}
|
|
}
|
|
numparms++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::StringizeTokens
|
|
================
|
|
*/
|
|
int idParser::StringizeTokens( idToken *tokens, idToken *token ) {
|
|
idToken *t;
|
|
|
|
token->type = TT_STRING;
|
|
token->whiteSpaceStart_p = NULL;
|
|
token->whiteSpaceEnd_p = NULL;
|
|
(*token) = "";
|
|
for ( t = tokens; t != NULL; t = t->next ) {
|
|
token->Append( t->c_str() );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::MergeTokens
|
|
================
|
|
*/
|
|
int idParser::MergeTokens( idToken *t1, idToken *t2 ) {
|
|
// merging of a name with a name or number
|
|
if ( t1->type == TT_NAME && (t2->type == TT_NAME || (t2->type == TT_NUMBER && !(t2->subtype & TT_FLOAT))) ) {
|
|
t1->Append( t2->c_str() );
|
|
return true;
|
|
}
|
|
// merging of two strings
|
|
if ( t1->type == TT_STRING && t2->type == TT_STRING ) {
|
|
t1->Append( t2->c_str() );
|
|
return true;
|
|
}
|
|
// merging of two numbers
|
|
if ( t1->type == TT_NUMBER && t2->type == TT_NUMBER &&
|
|
!(t1->subtype & (TT_HEX|TT_BINARY)) && !(t2->subtype & (TT_HEX|TT_BINARY)) &&
|
|
(!(t1->subtype & TT_FLOAT) || !(t2->subtype & TT_FLOAT)) ) {
|
|
t1->Append( t2->c_str() );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddBuiltinDefines
|
|
================
|
|
*/
|
|
void idParser::AddBuiltinDefines( void ) {
|
|
int i;
|
|
define_t *define;
|
|
struct {
|
|
char *string;
|
|
int id;
|
|
} builtin[] = {
|
|
{ "__LINE__", BUILTIN_LINE },
|
|
{ "__FILE__", BUILTIN_FILE },
|
|
{ "__DATE__", BUILTIN_DATE },
|
|
{ "__TIME__", BUILTIN_TIME },
|
|
{ "__STDC__", BUILTIN_STDC },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
for (i = 0; builtin[i].string; i++) {
|
|
define = (define_t *) Mem_Alloc(sizeof(define_t) + idStr::Length( builtin[i].string ) + 1);
|
|
define->name = (char *) define + sizeof(define_t);
|
|
strcpy( define->name, builtin[i].string );
|
|
define->flags = DEFINE_FIXED;
|
|
define->builtin = builtin[i].id;
|
|
define->numparms = 0;
|
|
define->parms = NULL;
|
|
define->tokens = NULL;
|
|
// add the define to the source
|
|
AddDefineToHash( define, idParser::definehash );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::CopyFirstDefine
|
|
================
|
|
*/
|
|
define_t *idParser::CopyFirstDefine( void ) {
|
|
int i;
|
|
|
|
for ( i = 0; i < DEFINEHASHSIZE; i++ ) {
|
|
if ( definehash[i] != NULL ) {
|
|
return CopyDefine( definehash[i] );
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpandBuiltinDefine
|
|
================
|
|
*/
|
|
int idParser::ExpandBuiltinDefine( idToken *deftoken, define_t *define, idToken **firsttoken, idToken **lasttoken ) {
|
|
idToken *token;
|
|
time_t t;
|
|
char *curtime;
|
|
char buf[MAX_STRING_CHARS];
|
|
|
|
token = new idToken( *deftoken );
|
|
switch( define->builtin ) {
|
|
case BUILTIN_LINE: {
|
|
sprintf( buf, "%d", deftoken->line );
|
|
(*token) = buf;
|
|
token->intvalue = deftoken->line;
|
|
token->floatvalue = deftoken->line;
|
|
token->type = TT_NUMBER;
|
|
token->subtype = TT_DECIMAL | TT_INTEGER | TT_VALUESVALID;
|
|
token->line = deftoken->line;
|
|
token->linesCrossed = deftoken->linesCrossed;
|
|
token->flags = 0;
|
|
*firsttoken = token;
|
|
*lasttoken = token;
|
|
break;
|
|
}
|
|
case BUILTIN_FILE: {
|
|
(*token) = idParser::scriptstack->GetFileName();
|
|
token->type = TT_NAME;
|
|
token->subtype = token->Length();
|
|
token->line = deftoken->line;
|
|
token->linesCrossed = deftoken->linesCrossed;
|
|
token->flags = 0;
|
|
*firsttoken = token;
|
|
*lasttoken = token;
|
|
break;
|
|
}
|
|
case BUILTIN_DATE: {
|
|
t = time(NULL);
|
|
curtime = ctime(&t);
|
|
(*token) = "\"";
|
|
token->Append( curtime+4 );
|
|
token[7] = '\0';
|
|
token->Append( curtime+20 );
|
|
token[10] = '\0';
|
|
token->Append( "\"" );
|
|
free(curtime);
|
|
token->type = TT_STRING;
|
|
token->subtype = token->Length();
|
|
token->line = deftoken->line;
|
|
token->linesCrossed = deftoken->linesCrossed;
|
|
token->flags = 0;
|
|
*firsttoken = token;
|
|
*lasttoken = token;
|
|
break;
|
|
}
|
|
case BUILTIN_TIME: {
|
|
t = time(NULL);
|
|
curtime = ctime(&t);
|
|
(*token) = "\"";
|
|
token->Append( curtime+11 );
|
|
token[8] = '\0';
|
|
token->Append( "\"" );
|
|
free(curtime);
|
|
token->type = TT_STRING;
|
|
token->subtype = token->Length();
|
|
token->line = deftoken->line;
|
|
token->linesCrossed = deftoken->linesCrossed;
|
|
token->flags = 0;
|
|
*firsttoken = token;
|
|
*lasttoken = token;
|
|
break;
|
|
}
|
|
case BUILTIN_STDC: {
|
|
idParser::Warning( "__STDC__ not supported" );
|
|
*firsttoken = NULL;
|
|
*lasttoken = NULL;
|
|
break;
|
|
}
|
|
default: {
|
|
*firsttoken = NULL;
|
|
*lasttoken = NULL;
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpandDefine
|
|
================
|
|
*/
|
|
int idParser::ExpandDefine( idToken *deftoken, define_t *define, idToken **firsttoken, idToken **lasttoken ) {
|
|
idToken *parms[MAX_DEFINEPARMS], *dt, *pt, *t;
|
|
idToken *t1, *t2, *first, *last, *nextpt, token;
|
|
int parmnum, i;
|
|
|
|
// if it is a builtin define
|
|
if ( define->builtin ) {
|
|
return idParser::ExpandBuiltinDefine( deftoken, define, firsttoken, lasttoken );
|
|
}
|
|
|
|
// if the define has parameters
|
|
if ( define->numparms ) {
|
|
if ( !idParser::ReadDefineParms( define, parms, MAX_DEFINEPARMS ) ) {
|
|
return false;
|
|
}
|
|
#ifdef DEBUG_EVAL
|
|
for ( i = 0; i < define->numparms; i++ ) {
|
|
Log_Write("define parms %d:", i);
|
|
for ( pt = parms[i]; pt; pt = pt->next ) {
|
|
Log_Write( "%s", pt->c_str() );
|
|
}
|
|
}
|
|
#endif //DEBUG_EVAL
|
|
}
|
|
|
|
// empty list at first
|
|
first = NULL;
|
|
last = NULL;
|
|
// create a list with tokens of the expanded define
|
|
for ( dt = define->tokens; dt != NULL; dt = dt->next ) {
|
|
parmnum = -1;
|
|
// if the token is a name, it could be a define parameter
|
|
if ( dt->type == TT_NAME ) {
|
|
parmnum = FindDefineParm( define, dt->c_str() );
|
|
}
|
|
// if it is a define parameter
|
|
if ( parmnum >= 0 ) {
|
|
for ( pt = parms[parmnum]; pt; pt = pt->next ) {
|
|
t = new idToken( *pt );
|
|
//add the token to the list
|
|
t->next = NULL;
|
|
if ( last ) {
|
|
last->next = t;
|
|
} else {
|
|
first = t;
|
|
}
|
|
last = t;
|
|
}
|
|
} else {
|
|
// if stringizing operator
|
|
if ( (*dt) == "#" ) {
|
|
// the stringizing operator must be followed by a define parameter
|
|
if ( dt->next != NULL ) {
|
|
parmnum = FindDefineParm( define, dt->next->c_str() );
|
|
} else {
|
|
parmnum = -1;
|
|
}
|
|
|
|
if ( parmnum >= 0 ) {
|
|
// step over the stringizing operator
|
|
dt = dt->next;
|
|
// stringize the define parameter tokens
|
|
if ( !StringizeTokens( parms[parmnum], &token ) ) {
|
|
Error( "can't stringize tokens" );
|
|
return false;
|
|
}
|
|
t = new idToken(token);
|
|
t->line = deftoken->line;
|
|
} else {
|
|
Warning( "stringizing operator without define parameter" );
|
|
continue;
|
|
}
|
|
} else {
|
|
t = new idToken( *dt );
|
|
t->line = deftoken->line;
|
|
}
|
|
// add the token to the list
|
|
t->next = NULL;
|
|
// the token being read from the define list should use the line number of
|
|
// the original file, not the header file
|
|
t->line = deftoken->line;
|
|
|
|
if ( last ) {
|
|
last->next = t;
|
|
} else {
|
|
first = t;
|
|
}
|
|
last = t;
|
|
}
|
|
}
|
|
// check for the merging operator
|
|
for ( t = first; t != NULL; ) {
|
|
if ( t->next != NULL ) {
|
|
// if the merging operator
|
|
if ( (*t->next) == "##" ) {
|
|
t1 = t;
|
|
t2 = t->next->next;
|
|
if ( t2 != NULL ) {
|
|
if ( !MergeTokens( t1, t2 ) ) {
|
|
Error( "can't merge '%s' with '%s'", t1->c_str(), t2->c_str() );
|
|
return false;
|
|
}
|
|
delete t1->next;
|
|
t1->next = t2->next;
|
|
if ( t2 == last ) {
|
|
last = t1;
|
|
}
|
|
delete t2;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
t = t->next;
|
|
}
|
|
// store the first and last token of the list
|
|
*firsttoken = first;
|
|
*lasttoken = last;
|
|
// free all the parameter tokens
|
|
for ( i = 0; i < define->numparms; i++ ) {
|
|
for ( pt = parms[i]; pt != NULL; pt = nextpt ) {
|
|
nextpt = pt->next;
|
|
delete pt;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpandDefineIntoSource
|
|
================
|
|
*/
|
|
int idParser::ExpandDefineIntoSource( idToken *deftoken, define_t *define ) {
|
|
idToken *firsttoken, *lasttoken;
|
|
|
|
if ( !ExpandDefine( deftoken, define, &firsttoken, &lasttoken ) ) {
|
|
return false;
|
|
}
|
|
// if the define is not empty
|
|
if ( firsttoken != NULL && lasttoken != NULL ) {
|
|
firsttoken->linesCrossed += deftoken->linesCrossed;
|
|
lasttoken->next = this->tokens;
|
|
this->tokens = firsttoken;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadLine
|
|
|
|
reads a token from the current line, continues reading on the next
|
|
line only if a backslash '\' is found
|
|
================
|
|
*/
|
|
int idParser::ReadLine( idToken *token, bool multiline ) {
|
|
int crossline;
|
|
|
|
if ( multiline ) {
|
|
while ( ReadSourceToken( token ) ) {
|
|
if ( *token == "%>" ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
crossline = 0;
|
|
do {
|
|
if ( !ReadSourceToken( token ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( token->linesCrossed > crossline ) {
|
|
UnreadSourceToken( *token );
|
|
return false;
|
|
}
|
|
crossline = 1;
|
|
} while( (*token) == "\\" );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddDefine
|
|
================
|
|
*/
|
|
int idParser::AddDefine( const char *string ) {
|
|
define_t *define;
|
|
|
|
if ( definehash == NULL ) {
|
|
definehash = (define_t **) Mem_ClearedAlloc( DEFINEHASHSIZE * sizeof(define_t *) );
|
|
}
|
|
|
|
define = DefineFromString( string );
|
|
if ( define == NULL ) {
|
|
return false;
|
|
}
|
|
AddDefineToHash( define, definehash );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddGlobalDefinesToSource
|
|
================
|
|
*/
|
|
void idParser::AddGlobalDefinesToSource( void ) {
|
|
define_t *define, *newdefine;
|
|
|
|
for ( define = globaldefines; define != NULL; define = define->next ) {
|
|
newdefine = CopyDefine( define );
|
|
AddDefineToHash( newdefine, definehash );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::AddInclude
|
|
================
|
|
*/
|
|
int idParser::AddInclude( const char *string ) {
|
|
idStr str = va( "#include <%s>", string );
|
|
idLexer src( str, str.Length(), "AddInclude", LEXFL_ALLOWPATHNAMES );
|
|
|
|
idToken token1;
|
|
idToken token2;
|
|
idToken token3;
|
|
idToken token4;
|
|
idToken token5;
|
|
src.ReadToken( &token1 );
|
|
src.ReadToken( &token2 );
|
|
src.ReadToken( &token3 );
|
|
src.ReadToken( &token4 );
|
|
src.ReadToken( &token5 );
|
|
UnreadToken( token5 );
|
|
UnreadToken( token4 );
|
|
UnreadToken( token3 );
|
|
UnreadToken( token2 );
|
|
UnreadToken( token1 );
|
|
|
|
//return Directive_include();
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idParser::AddIncludes
|
|
============
|
|
*/
|
|
int idParser::AddIncludes( const idStrList& includes ) {
|
|
int result = 0;
|
|
for( int i = includes.Num() - 1; i >= 0 ; i-- ) {
|
|
result |= AddInclude( includes[ i ] );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idParser::UnreadSignToken
|
|
================
|
|
*/
|
|
void idParser::UnreadSignToken( void ) {
|
|
idToken token;
|
|
|
|
token.line = scriptstack->GetLineNum();
|
|
token.whiteSpaceStart_p = NULL;
|
|
token.whiteSpaceEnd_p = NULL;
|
|
token.linesCrossed = 0;
|
|
token.flags = 0;
|
|
token = "-";
|
|
token.type = TT_PUNCTUATION;
|
|
token.subtype = P_SUB;
|
|
UnreadSourceToken( token );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::EvaluateTokens
|
|
================
|
|
*/
|
|
struct operator_t {
|
|
int op;
|
|
int priority;
|
|
int parentheses;
|
|
operator_t * prev;
|
|
operator_t * next;
|
|
};
|
|
|
|
struct value_t {
|
|
enum {
|
|
TYPE_STRING,
|
|
TYPE_INT,
|
|
TYPE_FLOAT
|
|
} type;
|
|
idStr string;
|
|
int intvalue;
|
|
double floatvalue;
|
|
int parentheses;
|
|
value_t * prev;
|
|
value_t * next;
|
|
};
|
|
|
|
int PC_OperatorPriority(int op) {
|
|
switch( op ) {
|
|
case P_MUL: return 15;
|
|
case P_DIV: return 15;
|
|
case P_MOD: return 15;
|
|
case P_ADD: return 14;
|
|
case P_SUB: return 14;
|
|
|
|
case P_LOGIC_AND: return 7;
|
|
case P_LOGIC_OR: return 6;
|
|
case P_LOGIC_GEQ: return 12;
|
|
case P_LOGIC_LEQ: return 12;
|
|
case P_LOGIC_EQ: return 11;
|
|
case P_LOGIC_UNEQ: return 11;
|
|
|
|
case P_LOGIC_NOT: return 16;
|
|
case P_LOGIC_GREATER: return 12;
|
|
case P_LOGIC_LESS: return 12;
|
|
|
|
case P_RSHIFT: return 13;
|
|
case P_LSHIFT: return 13;
|
|
|
|
case P_BIN_AND: return 10;
|
|
case P_BIN_OR: return 8;
|
|
case P_BIN_XOR: return 9;
|
|
case P_BIN_NOT: return 16;
|
|
|
|
case P_COLON: return 5;
|
|
case P_QUESTIONMARK: return 5;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//#define AllocValue() GetClearedMemory(sizeof(value_t));
|
|
//#define FreeValue(val) FreeMemory(val)
|
|
//#define AllocOperator(op) op = (operator_t *) GetClearedMemory(sizeof(operator_t));
|
|
//#define FreeOperator(op) FreeMemory(op);
|
|
|
|
#define MAX_VALUES 64
|
|
#define MAX_OPERATORS 64
|
|
|
|
#define AllocValue( val ) \
|
|
if ( numvalues >= MAX_VALUES ) { \
|
|
Error( "out of value space" ); \
|
|
error = 1; \
|
|
break; \
|
|
} else { \
|
|
val = &value_heap[numvalues++]; \
|
|
}
|
|
|
|
#define FreeValue( val )
|
|
|
|
#define AllocOperator( op ) \
|
|
if ( numoperators >= MAX_OPERATORS ) { \
|
|
Error( "out of operator space" ); \
|
|
error = 1; \
|
|
break; \
|
|
} else { \
|
|
op = &operator_heap[numoperators++]; \
|
|
}
|
|
|
|
#define FreeOperator( op )
|
|
|
|
int idParser::EvaluateTokens( idToken *tokens, signed long int *intvalue, double *floatvalue, int integer ) {
|
|
operator_t *o, *firstoperator, *lastoperator;
|
|
value_t *v, *firstvalue, *lastvalue, *v1, *v2;
|
|
idToken *t;
|
|
int brace = 0;
|
|
int parentheses = 0;
|
|
int error = 0;
|
|
int lastwasvalue = 0;
|
|
int negativevalue = 0;
|
|
int questmarkintvalue = 0;
|
|
double questmarkfloatvalue = 0;
|
|
int gotquestmarkvalue = false;
|
|
int lastoperatortype = 0;
|
|
|
|
operator_t operator_heap[MAX_OPERATORS];
|
|
int numoperators = 0;
|
|
value_t value_heap[MAX_VALUES];
|
|
int numvalues = 0;
|
|
|
|
firstoperator = lastoperator = NULL;
|
|
firstvalue = lastvalue = NULL;
|
|
if ( intvalue != NULL ) {
|
|
*intvalue = 0;
|
|
}
|
|
if ( floatvalue != NULL ) {
|
|
*floatvalue = 0;
|
|
}
|
|
for ( t = tokens; t != NULL; t = t->next ) {
|
|
switch( t->type ) {
|
|
case TT_NAME:
|
|
{
|
|
if ( lastwasvalue || negativevalue ) {
|
|
Error( "syntax error in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
if ( (*t) != "defined" ) {
|
|
Error( "undefined name '%s' in #if/#elif", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
t = t->next;
|
|
if ( (*t) == "(" ) {
|
|
brace = true;
|
|
t = t->next;
|
|
}
|
|
if ( t == NULL || t->type != TT_NAME ) {
|
|
Error( "defined() without name in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
AllocValue( v );
|
|
if ( FindHashedDefine( definehash, t->c_str() ) ) {
|
|
v->intvalue = 1;
|
|
v->floatvalue = 1;
|
|
} else {
|
|
v->intvalue = 0;
|
|
v->floatvalue = 0;
|
|
}
|
|
v->type = value_t::TYPE_INT;
|
|
v->parentheses = parentheses;
|
|
v->next = NULL;
|
|
v->prev = lastvalue;
|
|
if ( lastvalue != NULL ) {
|
|
lastvalue->next = v;
|
|
} else {
|
|
firstvalue = v;
|
|
}
|
|
lastvalue = v;
|
|
if ( brace ) {
|
|
t = t->next;
|
|
if ( t == NULL || (*t) != ")" ) {
|
|
Error( "defined missing ) in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
brace = false;
|
|
// defined() creates a value
|
|
lastwasvalue = 1;
|
|
break;
|
|
}
|
|
case TT_STRING:
|
|
{
|
|
if ( lastwasvalue ) {
|
|
Error( "syntax error in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
if ( lastoperator != NULL ) {
|
|
if ( lastoperator->op != P_LOGIC_EQ && lastoperator->op != P_LOGIC_UNEQ ) {
|
|
Error( "only == and != are allowed on strings" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
AllocValue( v );
|
|
v->string = *t;
|
|
v->type = value_t::TYPE_STRING;
|
|
v->parentheses = parentheses;
|
|
v->next = NULL;
|
|
v->prev = lastvalue;
|
|
if ( lastvalue != NULL ) {
|
|
lastvalue->next = v;
|
|
} else {
|
|
firstvalue = v;
|
|
}
|
|
lastvalue = v;
|
|
// last token was a value
|
|
lastwasvalue = 1;
|
|
negativevalue = 0;
|
|
break;
|
|
}
|
|
case TT_NUMBER:
|
|
{
|
|
if ( lastwasvalue ) {
|
|
Error( "syntax error in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
AllocValue( v );
|
|
if ( negativevalue ) {
|
|
v->intvalue = - t->GetIntValue();
|
|
v->floatvalue = - t->GetFloatValue();
|
|
} else {
|
|
v->intvalue = t->GetIntValue();
|
|
v->floatvalue = t->GetFloatValue();
|
|
}
|
|
if ( ( t->subtype & TT_INTEGER ) != 0 ) {
|
|
v->type = value_t::TYPE_INT;
|
|
} else {
|
|
v->type = value_t::TYPE_FLOAT;
|
|
}
|
|
v->parentheses = parentheses;
|
|
v->next = NULL;
|
|
v->prev = lastvalue;
|
|
if ( lastvalue != NULL ) {
|
|
lastvalue->next = v;
|
|
} else {
|
|
firstvalue = v;
|
|
}
|
|
lastvalue = v;
|
|
// last token was a value
|
|
lastwasvalue = 1;
|
|
negativevalue = 0;
|
|
break;
|
|
}
|
|
case TT_PUNCTUATION:
|
|
{
|
|
if ( negativevalue ) {
|
|
Error( "misplaced minus sign in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
if ( t->subtype == P_PARENTHESESOPEN ) {
|
|
parentheses++;
|
|
break;
|
|
} else if ( t->subtype == P_PARENTHESESCLOSE ) {
|
|
parentheses--;
|
|
if ( parentheses < 0 ) {
|
|
Error( "too many ) in #if/#elsif" );
|
|
error = 1;
|
|
}
|
|
break;
|
|
}
|
|
// check for invalid operators on floating point values
|
|
if ( !integer ) {
|
|
if ( t->subtype == P_BIN_NOT || t->subtype == P_MOD ||
|
|
t->subtype == P_RSHIFT || t->subtype == P_LSHIFT ||
|
|
t->subtype == P_BIN_AND || t->subtype == P_BIN_OR ||
|
|
t->subtype == P_BIN_XOR) {
|
|
Error( "illegal operator '%s' on floating point operands", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
if ( lastwasvalue && lastvalue->type == value_t::TYPE_STRING ) {
|
|
if ( t->subtype != P_LOGIC_EQ && t->subtype != P_LOGIC_UNEQ ) {
|
|
Error( "illegal operator '%s' on string operands", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
switch( t->subtype ) {
|
|
case P_LOGIC_NOT:
|
|
case P_BIN_NOT:
|
|
{
|
|
if ( lastwasvalue ) {
|
|
Error( "! or ~ after value in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case P_INC:
|
|
case P_DEC:
|
|
{
|
|
Error( "++ or -- used in #if/#elif" );
|
|
break;
|
|
}
|
|
case P_SUB:
|
|
{
|
|
if ( !lastwasvalue ) {
|
|
negativevalue = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
case P_MUL:
|
|
case P_DIV:
|
|
case P_MOD:
|
|
case P_ADD:
|
|
|
|
case P_LOGIC_AND:
|
|
case P_LOGIC_OR:
|
|
case P_LOGIC_GEQ:
|
|
case P_LOGIC_LEQ:
|
|
case P_LOGIC_EQ:
|
|
case P_LOGIC_UNEQ:
|
|
|
|
case P_LOGIC_GREATER:
|
|
case P_LOGIC_LESS:
|
|
|
|
case P_RSHIFT:
|
|
case P_LSHIFT:
|
|
|
|
case P_BIN_AND:
|
|
case P_BIN_OR:
|
|
case P_BIN_XOR:
|
|
|
|
case P_COLON:
|
|
case P_QUESTIONMARK:
|
|
{
|
|
if ( !lastwasvalue ) {
|
|
Error( "operator '%s' after operator in #if/#elif", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
Error( "invalid operator '%s' in #if/#elif", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
if ( !error && !negativevalue ) {
|
|
//o = (operator_t *) GetClearedMemory(sizeof(operator_t));
|
|
AllocOperator( o );
|
|
o->op = t->subtype;
|
|
o->priority = PC_OperatorPriority(t->subtype);
|
|
o->parentheses = parentheses;
|
|
o->next = NULL;
|
|
o->prev = lastoperator;
|
|
if ( lastoperator != NULL ) {
|
|
lastoperator->next = o;
|
|
} else {
|
|
firstoperator = o;
|
|
}
|
|
lastoperator = o;
|
|
lastwasvalue = 0;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
Error( "unknown '%s' in #if/#elif", t->c_str() );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
if ( error ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( !error ) {
|
|
if ( !lastwasvalue ) {
|
|
Error( "trailing operator in #if/#elif" );
|
|
error = 1;
|
|
} else if ( parentheses ) {
|
|
Error( "too many ( in #if/#elif" );
|
|
error = 1;
|
|
}
|
|
}
|
|
|
|
gotquestmarkvalue = false;
|
|
questmarkintvalue = 0;
|
|
questmarkfloatvalue = 0;
|
|
// while there are operators
|
|
while( !error && firstoperator ) {
|
|
v = firstvalue;
|
|
for ( o = firstoperator; o->next; o = o->next ) {
|
|
// if the current operator is nested deeper in parentheses than the next operator
|
|
if ( o->parentheses > o->next->parentheses ) {
|
|
break;
|
|
}
|
|
// if the current and next operator are nested equally deep in parentheses
|
|
if ( o->parentheses == o->next->parentheses ) {
|
|
// if the priority of the current operator is equal or higher than the priority of the next operator
|
|
if ( o->priority >= o->next->priority ) {
|
|
break;
|
|
}
|
|
}
|
|
// if the arity of the operator isn't equal to 1
|
|
if ( o->op != P_LOGIC_NOT && o->op != P_BIN_NOT ) {
|
|
v = v->next;
|
|
}
|
|
// if there's no value or no next value
|
|
if ( !v ) {
|
|
Error( "mising values in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
if ( error ) {
|
|
break;
|
|
}
|
|
v1 = v;
|
|
v2 = v->next;
|
|
#ifdef DEBUG_EVAL
|
|
if ( integer ) {
|
|
Log_Write( "operator %s, value1 = %d", scriptstack->getPunctuationFromId( o->op ), v1->intvalue );
|
|
if ( v2 ) Log_Write("value2 = %d", v2->intvalue);
|
|
} else {
|
|
Log_Write( "operator %s, value1 = %f", scriptstack->getPunctuationFromId( o->op ), v1->floatvalue );
|
|
if ( v2 ) Log_Write("value2 = %f", v2->floatvalue);
|
|
}
|
|
#endif //DEBUG_EVAL
|
|
switch( o->op ) {
|
|
case P_LOGIC_NOT: v1->intvalue = !v1->intvalue;
|
|
v1->floatvalue = !v1->floatvalue; break;
|
|
case P_BIN_NOT: v1->intvalue = ~v1->intvalue;
|
|
break;
|
|
case P_MUL: v1->intvalue *= v2->intvalue;
|
|
v1->floatvalue *= v2->floatvalue; break;
|
|
case P_DIV: if ( !v2->intvalue || !v2->floatvalue )
|
|
{
|
|
Error( "divide by zero in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
v1->intvalue /= v2->intvalue;
|
|
v1->floatvalue /= v2->floatvalue; break;
|
|
case P_MOD: if ( !v2->intvalue )
|
|
{
|
|
Error( "divide by zero in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
v1->intvalue %= v2->intvalue; break;
|
|
case P_ADD: v1->intvalue += v2->intvalue;
|
|
v1->floatvalue += v2->floatvalue; break;
|
|
case P_SUB: v1->intvalue -= v2->intvalue;
|
|
v1->floatvalue -= v2->floatvalue; break;
|
|
case P_LOGIC_AND: v1->intvalue = v1->intvalue && v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue && v2->floatvalue; break;
|
|
case P_LOGIC_OR: v1->intvalue = v1->intvalue || v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue || v2->floatvalue; break;
|
|
case P_LOGIC_GEQ: v1->intvalue = v1->intvalue >= v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue >= v2->floatvalue; break;
|
|
case P_LOGIC_LEQ: v1->intvalue = v1->intvalue <= v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue <= v2->floatvalue; break;
|
|
case P_LOGIC_EQ: v1->intvalue = ( v1->type == value_t::TYPE_STRING ) ? ( v1->string.Icmp( v2->string ) == 0 ) : ( v1->intvalue == v2->intvalue );
|
|
v1->floatvalue = ( v1->type == value_t::TYPE_STRING ) ? ( v1->string.Icmp( v2->string ) == 0 ) : ( v1->floatvalue == v2->floatvalue ); break;
|
|
case P_LOGIC_UNEQ: v1->intvalue = ( v1->type == value_t::TYPE_STRING ) ? ( v1->string.Icmp( v2->string ) != 0 ) : ( v1->intvalue != v2->intvalue );
|
|
v1->floatvalue = ( v1->type == value_t::TYPE_STRING ) ? ( v1->string.Icmp( v2->string ) != 0 ) : ( v1->floatvalue != v2->floatvalue ); break;
|
|
case P_LOGIC_GREATER: v1->intvalue = v1->intvalue > v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue > v2->floatvalue; break;
|
|
case P_LOGIC_LESS: v1->intvalue = v1->intvalue < v2->intvalue;
|
|
v1->floatvalue = v1->floatvalue < v2->floatvalue; break;
|
|
case P_RSHIFT: v1->intvalue >>= v2->intvalue;
|
|
break;
|
|
case P_LSHIFT: v1->intvalue <<= v2->intvalue;
|
|
break;
|
|
case P_BIN_AND: v1->intvalue &= v2->intvalue;
|
|
break;
|
|
case P_BIN_OR: v1->intvalue |= v2->intvalue;
|
|
break;
|
|
case P_BIN_XOR: v1->intvalue ^= v2->intvalue;
|
|
break;
|
|
case P_COLON:
|
|
{
|
|
if ( !gotquestmarkvalue ) {
|
|
Error( ": without ? in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
if ( integer ) {
|
|
if ( !questmarkintvalue ) {
|
|
v1->intvalue = v2->intvalue;
|
|
}
|
|
} else {
|
|
if ( !questmarkfloatvalue ) {
|
|
v1->floatvalue = v2->floatvalue;
|
|
}
|
|
}
|
|
gotquestmarkvalue = false;
|
|
break;
|
|
}
|
|
case P_QUESTIONMARK:
|
|
{
|
|
if ( gotquestmarkvalue ) {
|
|
Error( "? after ? in #if/#elif" );
|
|
error = 1;
|
|
break;
|
|
}
|
|
questmarkintvalue = v1->intvalue;
|
|
questmarkfloatvalue = v1->floatvalue;
|
|
gotquestmarkvalue = true;
|
|
break;
|
|
}
|
|
}
|
|
#ifdef DEBUG_EVAL
|
|
if ( integer ) Log_Write( "result value = %d", v1->intvalue );
|
|
else Log_Write( "result value = %f", v1->floatvalue );
|
|
#endif //DEBUG_EVAL
|
|
if (error)
|
|
break;
|
|
lastoperatortype = o->op;
|
|
// if not an operator with arity 1
|
|
if ( o->op != P_LOGIC_NOT && o->op != P_BIN_NOT ) {
|
|
// remove the second value if not question mark operator
|
|
if ( o->op != P_QUESTIONMARK ) {
|
|
v = v->next;
|
|
}
|
|
if ( v->prev != NULL ) {
|
|
v->prev->next = v->next;
|
|
} else {
|
|
firstvalue = v->next;
|
|
}
|
|
if ( v->next != NULL ) {
|
|
v->next->prev = v->prev;
|
|
} else {
|
|
lastvalue = v->prev;
|
|
}
|
|
FreeValue( v );
|
|
}
|
|
// remove the operator
|
|
if ( o->prev != NULL ) {
|
|
o->prev->next = o->next;
|
|
} else {
|
|
firstoperator = o->next;
|
|
}
|
|
if ( o->next != NULL ) {
|
|
o->next->prev = o->prev;
|
|
} else {
|
|
lastoperator = o->prev;
|
|
}
|
|
FreeOperator( o );
|
|
}
|
|
if ( firstvalue != NULL ) {
|
|
if ( intvalue != NULL ) *intvalue = firstvalue->intvalue;
|
|
if ( floatvalue != NULL ) *floatvalue = firstvalue->floatvalue;
|
|
}
|
|
for ( o = firstoperator; o != NULL; o = lastoperator ) {
|
|
lastoperator = o->next;
|
|
FreeOperator( o );
|
|
}
|
|
for ( v = firstvalue; v != NULL; v = lastvalue ) {
|
|
lastvalue = v->next;
|
|
FreeValue( v );
|
|
}
|
|
if ( !error ) {
|
|
return true;
|
|
}
|
|
if ( intvalue != NULL ) {
|
|
*intvalue = 0;
|
|
}
|
|
if ( floatvalue != NULL ) {
|
|
*floatvalue = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Evaluate
|
|
|
|
sing-line evalulate
|
|
================
|
|
*/
|
|
int idParser::Evaluate( signed long int *intvalue, double *floatvalue, int integer ) {
|
|
idToken token, *firsttoken, *lasttoken;
|
|
idToken *t, *nexttoken;
|
|
define_t *define;
|
|
int defined = false;
|
|
|
|
if ( intvalue != NULL ) {
|
|
*intvalue = 0;
|
|
}
|
|
if ( floatvalue != NULL ) {
|
|
*floatvalue = 0;
|
|
}
|
|
//
|
|
if ( !ReadLine( &token, false ) ) {
|
|
Error( "no value after #if/#elif" );
|
|
return false;
|
|
}
|
|
firsttoken = NULL;
|
|
lasttoken = NULL;
|
|
do {
|
|
//if the token is a name
|
|
if ( token.type == TT_NAME ) {
|
|
if ( defined ) {
|
|
defined = false;
|
|
t = new idToken( token );
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else if ( token == "defined" ) {
|
|
defined = true;
|
|
t = new idToken( token );
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else {
|
|
//then it must be a define
|
|
define = FindHashedDefine(idParser::definehash, token.c_str());
|
|
if ( !define ) {
|
|
Error( "can't Evaluate '%s', not defined", token.c_str() );
|
|
return false;
|
|
}
|
|
if ( !ExpandDefineIntoSource( &token, define ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
//if the token is a number or a punctuation
|
|
else if ( token.type == TT_NUMBER || token.type == TT_PUNCTUATION ) {
|
|
t = new idToken( token );
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else {
|
|
Error( "can't Evaluate '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
} while( ReadLine( &token, false ) );
|
|
|
|
if ( !EvaluateTokens( firsttoken, intvalue, floatvalue, integer ) ) {
|
|
return false;
|
|
}
|
|
|
|
#ifdef DEBUG_EVAL
|
|
Log_Write("eval:");
|
|
#endif //DEBUG_EVAL
|
|
for (t = firsttoken; t; t = nexttoken) {
|
|
#ifdef DEBUG_EVAL
|
|
Log_Write(" %s", t->c_str());
|
|
#endif //DEBUG_EVAL
|
|
nexttoken = t->next;
|
|
delete t;
|
|
}
|
|
#ifdef DEBUG_EVAL
|
|
if ( integer ) Log_Write( "eval result: %d", *intvalue );
|
|
else Log_Write( "eval result: %f", *floatvalue );
|
|
#endif //DEBUG_EVAL
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarEvaluate
|
|
|
|
multi-line evaluate
|
|
================
|
|
*/
|
|
int idParser::DollarEvaluate( signed long int *intvalue, double *floatvalue, int integer) {
|
|
int indent, defined = false;
|
|
idToken token, *firsttoken, *lasttoken;
|
|
idToken *t, *nexttoken;
|
|
define_t *define;
|
|
|
|
if ( intvalue != NULL ) {
|
|
*intvalue = 0;
|
|
}
|
|
if ( floatvalue != NULL ) {
|
|
*floatvalue = 0;
|
|
}
|
|
|
|
if ( !ReadSourceToken( &token ) || token != "(" ) {
|
|
Error( "no leading ( after $evalint/$evalfloat" );
|
|
return false;
|
|
}
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "nothing to Evaluate" );
|
|
return false;
|
|
}
|
|
indent = 1;
|
|
firsttoken = NULL;
|
|
lasttoken = NULL;
|
|
do {
|
|
//if the token is a name
|
|
if ( token.type == TT_NAME ) {
|
|
if ( defined ) {
|
|
defined = false;
|
|
t = new idToken( token );
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else if ( token == "defined" ) {
|
|
defined = true;
|
|
t = new idToken(token);
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else {
|
|
//then it must be a define
|
|
define = FindHashedDefine( definehash, token.c_str() );
|
|
if ( !define ) {
|
|
Warning( "can't Evaluate '%s', not defined", token.c_str() );
|
|
return false;
|
|
}
|
|
if ( !ExpandDefineIntoSource( &token, define ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if ( token.type == TT_STRING || token.type == TT_NUMBER || token.type == TT_PUNCTUATION ) { // if the token is a string, number or a punctuation
|
|
if ( token[0] == '(' ) {
|
|
indent++;
|
|
} else if ( token[0] == ')' ) {
|
|
indent--;
|
|
}
|
|
if ( indent <= 0 ) {
|
|
break;
|
|
}
|
|
t = new idToken(token);
|
|
t->next = NULL;
|
|
if ( lasttoken != NULL ) {
|
|
lasttoken->next = t;
|
|
} else {
|
|
firsttoken = t;
|
|
}
|
|
lasttoken = t;
|
|
} else {
|
|
Error( "can't Evaluate '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
} while( ReadSourceToken( &token ) );
|
|
|
|
if ( !EvaluateTokens( firsttoken, intvalue, floatvalue, integer ) ) {
|
|
return false;
|
|
}
|
|
|
|
#ifdef DEBUG_EVAL
|
|
Log_Write("$eval:");
|
|
#endif //DEBUG_EVAL
|
|
for ( t = firsttoken; t != NULL; t = nexttoken ) {
|
|
#ifdef DEBUG_EVAL
|
|
Log_Write(" %s", t->c_str());
|
|
#endif //DEBUG_EVAL
|
|
nexttoken = t->next;
|
|
delete t;
|
|
}
|
|
#ifdef DEBUG_EVAL
|
|
if ( integer ) Log_Write( "$eval result: %d", *intvalue );
|
|
else Log_Write( "$eval result: %f", *floatvalue );
|
|
#endif //DEBUG_EVAL
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_include
|
|
================
|
|
*/
|
|
int idParser::Directive_include( void ) {
|
|
idLexer *script;
|
|
idToken token;
|
|
idStr path;
|
|
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "#include without file name" );
|
|
return false;
|
|
}
|
|
if ( token.linesCrossed > 0 ) {
|
|
Error( "#include without file name" );
|
|
return false;
|
|
}
|
|
if ( token.type == TT_STRING ) {
|
|
script = new idLexer;
|
|
script->SetFlags( flags );
|
|
script->SetPunctuations( punctuations );
|
|
// try relative to the current file
|
|
path = scriptstack->GetFileName();
|
|
path.StripFilename();
|
|
path += "/";
|
|
path += token;
|
|
if ( !script->LoadFile( path, OSPath, startLine ) ) {
|
|
// try absolute path
|
|
path = token;
|
|
if ( !script->LoadFile( path, OSPath, startLine ) ) {
|
|
// try from the include path
|
|
path = includepath + token;
|
|
if ( !script->LoadFile( path, OSPath, startLine ) ) {
|
|
delete script;
|
|
script = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( token.type == TT_PUNCTUATION && token == "<" ) {
|
|
path = includepath;
|
|
while( ReadSourceToken( &token ) ) {
|
|
if ( token.linesCrossed > 0 ) {
|
|
UnreadSourceToken( token );
|
|
break;
|
|
}
|
|
if ( token.type == TT_PUNCTUATION && token == ">" ) {
|
|
break;
|
|
}
|
|
path += token;
|
|
}
|
|
if ( token != ">" ) {
|
|
Warning( "#include missing trailing >" );
|
|
}
|
|
if ( !path.Length() ) {
|
|
Error( "#include without file name between < >" );
|
|
return false;
|
|
}
|
|
if ( flags & LEXFL_NOBASEINCLUDES ) {
|
|
return true;
|
|
}
|
|
script = new idLexer;
|
|
script->SetFlags( flags );
|
|
script->SetPunctuations( punctuations );
|
|
if ( !script->LoadFile( includepath + path, OSPath, startLine ) ) {
|
|
delete script;
|
|
script = NULL;
|
|
}
|
|
}
|
|
else {
|
|
Error( "#include without file name" );
|
|
return false;
|
|
}
|
|
if ( script == NULL ) {
|
|
Error( "file '%s' not found", path.c_str() );
|
|
return false;
|
|
}
|
|
|
|
if ( !PushScript( script ) ) {
|
|
delete script;
|
|
script = NULL;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_define
|
|
================
|
|
*/
|
|
int idParser::Directive_define( bool isTemplate ) {
|
|
idToken token, *t, *last;
|
|
define_t *define;
|
|
|
|
if ( !ReadLine( &token, isTemplate ) ) {
|
|
Error( "#define without name" );
|
|
return false;
|
|
}
|
|
if ( token.type != TT_NAME ) {
|
|
UnreadSourceToken( token );
|
|
Error( "expected name after #define, found '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
// check if the define already exists
|
|
define = FindHashedDefine( definehash, token.c_str() );
|
|
if ( define ) {
|
|
if ( define->flags & DEFINE_FIXED ) {
|
|
Error( "can't redefine '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
Warning( "redefinition of '%s'", token.c_str() );
|
|
// unread the define name before executing the #undef directive
|
|
UnreadSourceToken( token );
|
|
if ( !Directive_undef() )
|
|
return false;
|
|
// if the define was not removed (define->flags & DEFINE_FIXED)
|
|
define = FindHashedDefine( definehash, token.c_str() );
|
|
}
|
|
// allocate define
|
|
define = (define_t *) Mem_ClearedAlloc( sizeof(define_t) + token.Length() + 1 );
|
|
define->name = (char *) define + sizeof( define_t );
|
|
strcpy( define->name, token.c_str() );
|
|
// add the define to the source
|
|
AddDefineToHash( define, definehash );
|
|
// if nothing is defined, just return
|
|
if ( !ReadLine( &token, isTemplate ) ) {
|
|
return true;
|
|
}
|
|
// if it is a define with parameters
|
|
if ( token.WhiteSpaceBeforeToken() == 0 && token == "(" ) {
|
|
// read the define parameters
|
|
last = NULL;
|
|
if ( !CheckTokenString( ")" ) ) {
|
|
while( 1 ) {
|
|
if ( !ReadLine( &token, isTemplate ) ) {
|
|
Error( "expected define parameter" );
|
|
return false;
|
|
}
|
|
// if it isn't a name
|
|
if ( token.type != TT_NAME ) {
|
|
Error( "invalid define parameter" );
|
|
return false;
|
|
}
|
|
|
|
if ( FindDefineParm( define, token.c_str() ) >= 0 ) {
|
|
Error( "two the same define parameters" );
|
|
return false;
|
|
}
|
|
// add the define parm
|
|
t = new idToken( token );
|
|
t->ClearTokenWhiteSpace();
|
|
t->next = NULL;
|
|
if ( last ) {
|
|
last->next = t;
|
|
} else {
|
|
define->parms = t;
|
|
}
|
|
last = t;
|
|
define->numparms++;
|
|
// read next token
|
|
if ( !ReadLine( &token, isTemplate ) ) {
|
|
Error( "define parameters not terminated" );
|
|
return false;
|
|
}
|
|
|
|
if ( token == ")" ) {
|
|
break;
|
|
}
|
|
// then it must be a comma
|
|
if ( token != "," ) {
|
|
Error( "define not terminated" );
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if ( !ReadLine( &token, isTemplate ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// read the defined stuff
|
|
last = NULL;
|
|
do {
|
|
if ( isTemplate && token.type == TT_PUNCTUATION && token == "$" ) {
|
|
idToken end;
|
|
ReadLine( &end, isTemplate );
|
|
if ( end == "endtemplate" ) {
|
|
break;
|
|
}
|
|
UnreadSourceToken( end );
|
|
}
|
|
t = new idToken( token );
|
|
if ( t->type == TT_NAME && !idStr::Cmp( t->c_str(), define->name ) ) {
|
|
t->flags |= TOKEN_FL_RECURSIVE_DEFINE;
|
|
Warning( "recursive define of '%s' (removed recursion)", define->name );
|
|
}
|
|
t->whiteSpaceStart_p = t->whiteSpaceEnd_p = NULL;
|
|
t->next = NULL;
|
|
if ( last != NULL ) {
|
|
last->next = t;
|
|
} else {
|
|
define->tokens = t;
|
|
}
|
|
last = t;
|
|
} while( ReadLine( &token, isTemplate ) );
|
|
|
|
if ( last != NULL ) {
|
|
// check for merge operators at the beginning or end
|
|
if ( (*define->tokens) == "##" || (*last) == "##" ) {
|
|
Error( "define with misplaced ##" );
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_undef
|
|
================
|
|
*/
|
|
int idParser::Directive_undef( void ) {
|
|
idToken token;
|
|
define_t *define, *lastdefine;
|
|
int hash;
|
|
|
|
if ( !ReadLine( &token, false ) ) {
|
|
Error( "undef without name" );
|
|
return false;
|
|
}
|
|
if ( token.type != TT_NAME ) {
|
|
UnreadSourceToken( token );
|
|
Error( "expected name but found '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
|
|
hash = PC_NameHash( token.c_str() );
|
|
for ( lastdefine = NULL, define = definehash[hash]; define; define = define->hashnext ) {
|
|
if ( !idStr::Cmp( define->name, token.c_str() ) ) {
|
|
if ( define->flags & DEFINE_FIXED ) {
|
|
idParser::Warning( "can't undef '%s'", token.c_str() );
|
|
} else {
|
|
if ( lastdefine ) {
|
|
lastdefine->hashnext = define->hashnext;
|
|
} else {
|
|
definehash[hash] = define->hashnext;
|
|
}
|
|
FreeDefine( define );
|
|
}
|
|
break;
|
|
}
|
|
lastdefine = define;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_if_def
|
|
================
|
|
*/
|
|
int idParser::Directive_if_def( int type ) {
|
|
idToken token;
|
|
define_t *d;
|
|
int skip;
|
|
|
|
if ( !ReadLine( &token, false ) ) {
|
|
Error( "#ifdef without name" );
|
|
return false;
|
|
}
|
|
if ( token.type != TT_NAME ) {
|
|
UnreadSourceToken( token );
|
|
Error( "expected name after #ifdef, found '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
d = FindHashedDefine( definehash, token.c_str() );
|
|
skip = ( type == INDENT_IFDEF ) == ( d == NULL );
|
|
PushIndent( type, skip, !skip );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_ifdef
|
|
================
|
|
*/
|
|
int idParser::Directive_ifdef( void ) {
|
|
return Directive_if_def( INDENT_IFDEF );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_ifndef
|
|
================
|
|
*/
|
|
int idParser::Directive_ifndef( void ) {
|
|
return Directive_if_def( INDENT_IFNDEF );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_else
|
|
================
|
|
*/
|
|
int idParser::Directive_else( void ) {
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type ) {
|
|
Error( "misplaced #else" );
|
|
return false;
|
|
}
|
|
if ( type == INDENT_ELSE ) {
|
|
Error( "#else after #else" );
|
|
return false;
|
|
}
|
|
PushIndent( INDENT_ELSE, skipElse, 1 );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_endif
|
|
================
|
|
*/
|
|
int idParser::Directive_endif( void ) {
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type ) {
|
|
Error( "misplaced #endif" );
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_if
|
|
================
|
|
*/
|
|
int idParser::Directive_if( void ) {
|
|
signed long int value = 0;
|
|
int skip;
|
|
|
|
if ( !this->skip ) {
|
|
if ( !Evaluate( &value, NULL, true ) ) {
|
|
return false;
|
|
}
|
|
skip = ( value == 0 );
|
|
} else {
|
|
skip = 1;
|
|
}
|
|
|
|
PushIndent( INDENT_IF, skip, !skip );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_elif
|
|
================
|
|
*/
|
|
int idParser::Directive_elif( void ) {
|
|
signed long int value = 0;
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type || type == INDENT_ELSE ) {
|
|
Error( "misplaced #elif" );
|
|
return false;
|
|
}
|
|
if ( !this->skip ) {
|
|
if ( !Evaluate( &value, NULL, true ) ) {
|
|
return false;
|
|
}
|
|
skip = skipElse || ( value == 0 );
|
|
} else {
|
|
skip = 1;
|
|
}
|
|
|
|
skipElse = skipElse || !skip;
|
|
PushIndent( INDENT_ELIF, skip, skipElse );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_line
|
|
================
|
|
*/
|
|
int idParser::Directive_line( void ) {
|
|
idToken token;
|
|
|
|
Error( "#line directive not supported" );
|
|
while( ReadLine( &token, false ) ) {
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_error
|
|
================
|
|
*/
|
|
int idParser::Directive_error( void ) {
|
|
idToken token;
|
|
|
|
if ( !ReadLine( &token, false ) || token.type != TT_STRING ) {
|
|
Error( "#error without string" );
|
|
return false;
|
|
}
|
|
Error( "#error: %s", token.c_str() );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_warning
|
|
================
|
|
*/
|
|
int idParser::Directive_warning( void ) {
|
|
idToken token;
|
|
|
|
if ( !ReadLine( &token, false ) || token.type != TT_STRING ) {
|
|
Warning( "#warning without string" );
|
|
return false;
|
|
}
|
|
Warning( "#warning: %s", token.c_str() );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Directive_pragma
|
|
================
|
|
*/
|
|
int idParser::Directive_pragma( void ) {
|
|
idToken token;
|
|
idStr pragma;
|
|
|
|
while( ReadLine( &token, false ) ) {
|
|
pragma += token + " ";
|
|
}
|
|
pragma.StripTrailing( " " );
|
|
|
|
if ( pragmaCallback != NULL ) {
|
|
pragmaCallback( pragmaData, pragma );
|
|
} else {
|
|
Warning( "#pragma directive '%s' not supported", pragma.c_str() );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadDirective
|
|
================
|
|
*/
|
|
int idParser::ReadDirective( void ) {
|
|
idToken token;
|
|
|
|
//read the directive name
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "found '#' without name" );
|
|
return false;
|
|
}
|
|
//directive name must be on the same line
|
|
if ( token.linesCrossed > 0 ) {
|
|
UnreadSourceToken( token );
|
|
Error( "found '#' at end of line" );
|
|
return false;
|
|
}
|
|
//if if is a name
|
|
if ( token.type == TT_NAME ) {
|
|
if ( token == "if" ) {
|
|
return Directive_if();
|
|
} else if ( token == "ifdef" ) {
|
|
return Directive_ifdef();
|
|
} else if ( token == "ifndef" ) {
|
|
return Directive_ifndef();
|
|
} else if ( token == "elif" ) {
|
|
return Directive_elif();
|
|
} else if ( token == "else" ) {
|
|
return Directive_else();
|
|
} else if ( token == "endif" ) {
|
|
return Directive_endif();
|
|
}
|
|
|
|
if ( skip > 0 ) {
|
|
// skip the rest of the line
|
|
while( ReadLine( &token, false ) ) {
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ( token == "include" ) {
|
|
return Directive_include();
|
|
} else if ( token == "define" ) {
|
|
return Directive_define( false );
|
|
} else if ( token == "undef" ) {
|
|
return Directive_undef();
|
|
} else if ( token == "line" ) {
|
|
return Directive_line();
|
|
} else if ( token == "error" ) {
|
|
return Directive_error();
|
|
} else if ( token == "warning" ) {
|
|
return Directive_warning();
|
|
} else if ( token == "pragma" ) {
|
|
return Directive_pragma();
|
|
}
|
|
}
|
|
Error( "unknown precompiler directive '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_if_def
|
|
|
|
multi-line if with parenthesis
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_if_def( int type ) {
|
|
idToken token;
|
|
define_t *d;
|
|
int skip;
|
|
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "$ifdef without name" );
|
|
return false;
|
|
}
|
|
if ( token.type != TT_NAME ) {
|
|
UnreadSourceToken( token );
|
|
Error( "expected name after $ifdef, found '%s'", token.c_str() );
|
|
return false;
|
|
}
|
|
d = FindHashedDefine( definehash, token.c_str() );
|
|
skip = ( type == INDENT_IFDEF ) == ( d == NULL );
|
|
PushIndent( type, skip, !skip );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_ifdef
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_ifdef( void ) {
|
|
return DollarDirective_if_def( INDENT_IFDEF );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_ifndef
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_ifndef( void ) {
|
|
return DollarDirective_if_def( INDENT_IFNDEF );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_else
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_else( void ) {
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type ) {
|
|
Error( "misplaced $else" );
|
|
return false;
|
|
}
|
|
if ( type == INDENT_ELSE ) {
|
|
Error( "$else after $else" );
|
|
return false;
|
|
}
|
|
PushIndent( INDENT_ELSE, skipElse, 1 );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_endif
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_endif( void ) {
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type ) {
|
|
Error( "misplaced $endif" );
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_if
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_if( void ) {
|
|
signed long int value = 0;
|
|
int skip;
|
|
|
|
if ( !this->skip ) {
|
|
if ( !DollarEvaluate( &value, NULL, true ) ) {
|
|
return false;
|
|
}
|
|
skip = ( value == 0 );
|
|
} else {
|
|
skip = 1;
|
|
}
|
|
|
|
PushIndent( INDENT_IF, skip, !skip );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_elif
|
|
|
|
multi-line elif with parenthesis
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_elif( void ) {
|
|
signed long int value = 0;
|
|
int type, skip, skipElse;
|
|
|
|
PopIndent( type, skip, skipElse );
|
|
if ( !type || type == INDENT_ELSE ) {
|
|
Error( "misplaced $elif" );
|
|
return false;
|
|
}
|
|
if ( !this->skip ) {
|
|
if ( !DollarEvaluate( &value, NULL, true ) ) {
|
|
return false;
|
|
}
|
|
skip = skipElse || ( value == 0 );
|
|
} else {
|
|
skip = 1;
|
|
}
|
|
|
|
skipElse = skipElse || !skip;
|
|
PushIndent( INDENT_ELIF, skip, skipElse );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_evalint
|
|
|
|
multi-line evaluate integer with parenthesis
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_evalint( void ) {
|
|
signed long int value;
|
|
idToken token;
|
|
char buf[128];
|
|
|
|
if ( !DollarEvaluate( &value, NULL, true ) ) {
|
|
return false;
|
|
}
|
|
|
|
token.line = scriptstack->GetLineNum();
|
|
token.whiteSpaceStart_p = NULL;
|
|
token.whiteSpaceEnd_p = NULL;
|
|
token.linesCrossed = 0;
|
|
token.flags = 0;
|
|
sprintf( buf, "%d", abs( value ) );
|
|
token = buf;
|
|
token.type = TT_NUMBER;
|
|
token.subtype = TT_INTEGER | TT_LONG | TT_DECIMAL | TT_VALUESVALID;
|
|
token.intvalue = abs( value );
|
|
token.floatvalue = abs( value );
|
|
UnreadSourceToken( token );
|
|
if ( value < 0 ) {
|
|
UnreadSignToken();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::DollarDirective_evalfloat
|
|
|
|
multi-line evalulate float with parenthesis
|
|
================
|
|
*/
|
|
int idParser::DollarDirective_evalfloat( void ) {
|
|
double value;
|
|
idToken token;
|
|
char buf[128];
|
|
|
|
if ( !DollarEvaluate( NULL, &value, false ) ) {
|
|
return false;
|
|
}
|
|
|
|
token.line = scriptstack->GetLineNum();
|
|
token.whiteSpaceStart_p = NULL;
|
|
token.whiteSpaceEnd_p = NULL;
|
|
token.linesCrossed = 0;
|
|
token.flags = 0;
|
|
sprintf( buf, "%1.2f", fabs( value ) );
|
|
token = buf;
|
|
token.type = TT_NUMBER;
|
|
token.subtype = TT_FLOAT | TT_LONG | TT_DECIMAL | TT_VALUESVALID;
|
|
token.intvalue = (unsigned long) fabs( value );
|
|
token.floatvalue = fabs( value );
|
|
UnreadSourceToken( token );
|
|
if ( value < 0 ) {
|
|
UnreadSignToken();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadDollarDirective
|
|
================
|
|
*/
|
|
int idParser::ReadDollarDirective( void ) {
|
|
idToken token;
|
|
|
|
// read the directive name
|
|
if ( !ReadSourceToken( &token ) ) {
|
|
Error( "found '$' without name" );
|
|
return false;
|
|
}
|
|
// directive name must be on the same line
|
|
if ( token.linesCrossed > 0 ) {
|
|
UnreadSourceToken( token );
|
|
Error( "found '$' at end of line" );
|
|
return false;
|
|
}
|
|
// if if is a name
|
|
if ( token.type == TT_NAME ) {
|
|
if ( token == "if" ) {
|
|
return DollarDirective_if();
|
|
} else if ( token == "ifdef" ) {
|
|
return DollarDirective_ifdef();
|
|
} else if ( token == "ifndef" ) {
|
|
return DollarDirective_ifndef();
|
|
} else if ( token == "elif" ) {
|
|
return DollarDirective_elif();
|
|
} else if ( token == "else" ) {
|
|
return DollarDirective_else();
|
|
} else if ( token == "endif" ) {
|
|
return DollarDirective_endif();
|
|
} else if ( token == "breakonparse" ) {
|
|
return true;
|
|
}
|
|
|
|
if ( skip > 0 ) {
|
|
return true;
|
|
}
|
|
|
|
if ( token == "evalint" ) {
|
|
return DollarDirective_evalint();
|
|
} else if ( token == "evalfloat" ) {
|
|
return DollarDirective_evalfloat();
|
|
} else if ( token == "template" ) {
|
|
return Directive_define( true );
|
|
}
|
|
}
|
|
UnreadSourceToken( token );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadToken
|
|
================
|
|
*/
|
|
int idParser::ReadToken( idToken *token ) {
|
|
define_t *define;
|
|
|
|
while( 1 ) {
|
|
if ( !ReadSourceToken( token ) ) {
|
|
return false;
|
|
}
|
|
// if dollar directives are allowed
|
|
if ( ( scriptstack->GetFlags() & LEXFL_NODOLLARPRECOMPILE ) == 0 ) {
|
|
// check for special precompiler directives
|
|
if ( token->type == TT_PUNCTUATION && ( *token)[0] == '$' && (*token)[1] == '\0' ) {
|
|
// read the precompiler directive
|
|
if ( ReadDollarDirective() ) {
|
|
continue;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// check for precompiler directives
|
|
if ( token->type == TT_PUNCTUATION && (*token)[0] == '#' && (*token)[1] == '\0' ) {
|
|
// read the precompiler directive
|
|
if ( !ReadDirective() ) {
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// if skipping source because of conditional compilation
|
|
if ( skip ) {
|
|
continue;
|
|
}
|
|
// recursively concatenate strings that are behind each other still resolving defines
|
|
if ( token->type == TT_STRING && !( scriptstack->GetFlags() & LEXFL_NOSTRINGCONCAT ) ) {
|
|
idToken newtoken;
|
|
if ( ReadToken( &newtoken ) ) {
|
|
if ( newtoken.type == TT_STRING ) {
|
|
token->Append( newtoken.c_str() );
|
|
} else {
|
|
UnreadSourceToken( newtoken );
|
|
}
|
|
}
|
|
}
|
|
// if the token is a name
|
|
if ( token->type == TT_NAME && !( token->flags & TOKEN_FL_RECURSIVE_DEFINE ) ) {
|
|
// check if the name is a define
|
|
define = FindHashedDefine( definehash, token->c_str() );
|
|
// if it is a define
|
|
if ( define != NULL ) {
|
|
// expand the defined
|
|
if ( !ExpandDefineIntoSource( token, define ) ) {
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
// found a token
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpectTokenString
|
|
================
|
|
*/
|
|
bool idParser::ExpectTokenString( const char* string, idToken* other ) {
|
|
idToken temp;
|
|
idToken* token = other ? other : &temp;
|
|
|
|
if ( !idParser::ReadToken( token ) ) {
|
|
idParser::Error( "couldn't find expected '%s'", string );
|
|
return false;
|
|
}
|
|
|
|
if ( *token != string ) {
|
|
idParser::Error( "expected '%s' but found '%s'", string, token->c_str() );
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpectTokenType
|
|
================
|
|
*/
|
|
int idParser::ExpectTokenType( int type, int subtype, idToken *token ) {
|
|
idStr str;
|
|
|
|
if ( !idParser::ReadToken( token ) ) {
|
|
idParser::Error( "couldn't read expected token" );
|
|
return 0;
|
|
}
|
|
|
|
if ( token->type != type ) {
|
|
switch( type ) {
|
|
case TT_STRING: str = "string"; break;
|
|
case TT_LITERAL: str = "literal"; break;
|
|
case TT_NUMBER: str = "number"; break;
|
|
case TT_NAME: str = "name"; break;
|
|
case TT_PUNCTUATION: str = "punctuation"; break;
|
|
default: str = "unknown type"; break;
|
|
}
|
|
idParser::Error( "expected a %s but found '%s'", str.c_str(), token->c_str() );
|
|
return 0;
|
|
}
|
|
if ( token->type == TT_NUMBER ) {
|
|
if ( (token->subtype & subtype) != subtype ) {
|
|
str.Clear();
|
|
if ( subtype & TT_DECIMAL ) str = "decimal ";
|
|
if ( subtype & TT_HEX ) str = "hex ";
|
|
if ( subtype & TT_OCTAL ) str = "octal ";
|
|
if ( subtype & TT_BINARY ) str = "binary ";
|
|
if ( subtype & TT_UNSIGNED ) str += "unsigned ";
|
|
if ( subtype & TT_LONG ) str += "long ";
|
|
if ( subtype & TT_FLOAT ) str += "float ";
|
|
if ( subtype & TT_INTEGER ) str += "integer ";
|
|
str.StripTrailing( ' ' );
|
|
idParser::Error( "expected %s but found '%s'", str.c_str(), token->c_str() );
|
|
return 0;
|
|
}
|
|
}
|
|
else if ( token->type == TT_PUNCTUATION ) {
|
|
if ( subtype < 0 ) {
|
|
idParser::Error( "BUG: wrong punctuation subtype" );
|
|
return 0;
|
|
}
|
|
if ( token->subtype != subtype ) {
|
|
idParser::Error( "expected '%s' but found '%s'", scriptstack->GetPunctuationFromId( subtype ), token->c_str() );
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ExpectAnyToken
|
|
================
|
|
*/
|
|
int idParser::ExpectAnyToken( idToken *token ) {
|
|
if (!idParser::ReadToken( token )) {
|
|
idParser::Error( "couldn't read expected token" );
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::CheckTokenString
|
|
================
|
|
*/
|
|
int idParser::CheckTokenString( const char *string ) {
|
|
idToken tok;
|
|
|
|
if ( !ReadToken( &tok ) ) {
|
|
return false;
|
|
}
|
|
//if the token is available
|
|
if ( tok == string ) {
|
|
return true;
|
|
}
|
|
UnreadSourceToken( tok );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::CheckTokenType
|
|
================
|
|
*/
|
|
int idParser::CheckTokenType( int type, int subtype, idToken *token ) {
|
|
idToken tok;
|
|
|
|
if ( !ReadToken( &tok ) ) {
|
|
return false;
|
|
}
|
|
//if the type matches
|
|
if ( tok.type == type && ( tok.subtype & subtype ) == subtype ) {
|
|
*token = tok;
|
|
return true;
|
|
}
|
|
UnreadSourceToken( tok );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::PeekTokenString
|
|
================
|
|
*/
|
|
int idParser::PeekTokenString( const char *string ) {
|
|
idToken tok;
|
|
|
|
if ( !ReadToken( &tok ) ) {
|
|
return false;
|
|
}
|
|
|
|
UnreadSourceToken( tok );
|
|
|
|
// if the token is available
|
|
if ( tok == string ) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::PeekTokenType
|
|
================
|
|
*/
|
|
int idParser::PeekTokenType( int type, int subtype, idToken *token ) {
|
|
idToken tok;
|
|
|
|
if ( !ReadToken( &tok ) ) {
|
|
return false;
|
|
}
|
|
|
|
UnreadSourceToken( tok );
|
|
|
|
// if the type matches
|
|
if ( tok.type == type && ( tok.subtype & subtype ) == subtype ) {
|
|
*token = tok;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SkipUntilString
|
|
================
|
|
*/
|
|
int idParser::SkipUntilString( const char *string, idToken* token ) {
|
|
while( ReadToken( token ) ) {
|
|
if ( *token == string ) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SkipRestOfLine
|
|
================
|
|
*/
|
|
int idParser::SkipRestOfLine( void ) {
|
|
idToken token;
|
|
|
|
while( ReadToken( &token ) ) {
|
|
if ( token.linesCrossed ) {
|
|
UnreadSourceToken( token );
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idParser::SkipBracedSection
|
|
|
|
Skips until a matching close brace is found.
|
|
Internal brace depths are properly skipped.
|
|
=================
|
|
*/
|
|
int idParser::SkipBracedSection( bool parseFirstBrace ) {
|
|
idToken token;
|
|
int depth;
|
|
|
|
depth = parseFirstBrace ? 0 : 1;
|
|
do {
|
|
if ( !ReadToken( &token ) ) {
|
|
return false;
|
|
}
|
|
if( token.type == TT_PUNCTUATION ) {
|
|
if( token == "{" ) {
|
|
depth++;
|
|
} else if ( token == "}" ) {
|
|
depth--;
|
|
}
|
|
}
|
|
} while( depth );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idParser::ParseBracedSection
|
|
|
|
The next token should be an open brace.
|
|
Parses until a matching close brace is found.
|
|
Internal brace depths are properly skipped.
|
|
=================
|
|
*/
|
|
const char* idParser::ParseBracedSection( idStr& out, int tabs, bool parseFirstBrace, char intro, char outro ) {
|
|
idToken token;
|
|
int i, depth;
|
|
bool doTabs;
|
|
|
|
char temp[ 2 ] = { 0, 0 };
|
|
*temp = intro;
|
|
|
|
out.Empty();
|
|
if ( parseFirstBrace ) {
|
|
if ( !ExpectTokenString( temp ) ) {
|
|
return out.c_str();
|
|
}
|
|
out = temp;
|
|
}
|
|
depth = 1;
|
|
doTabs = ( tabs >= 0 );
|
|
do {
|
|
if ( !ReadToken( &token ) ) {
|
|
Error( "missing closing brace" );
|
|
return out.c_str();
|
|
}
|
|
|
|
// if the token is on a new line
|
|
for ( i = 0; i < token.linesCrossed; i++ ) {
|
|
out += "\r\n";
|
|
}
|
|
|
|
if ( doTabs && token.linesCrossed ) {
|
|
i = tabs;
|
|
if ( token[ 0 ] == outro && i > 0 ) {
|
|
i--;
|
|
}
|
|
while( i-- > 0 ) {
|
|
out += "\t";
|
|
}
|
|
}
|
|
if ( token.type != TT_STRING ) {
|
|
if ( token[ 0 ] == intro ) {
|
|
depth++;
|
|
if ( doTabs ) {
|
|
tabs++;
|
|
}
|
|
} else if ( token[ 0 ] == outro ) {
|
|
depth--;
|
|
if ( doTabs ) {
|
|
tabs--;
|
|
}
|
|
}
|
|
out += token;
|
|
} else {
|
|
out += "\"" + token + "\"";
|
|
}
|
|
out += " ";
|
|
} while( depth );
|
|
|
|
return out.c_str();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idParser::ParseRestOfLine
|
|
|
|
parse the rest of the line
|
|
=================
|
|
*/
|
|
const char *idParser::ParseRestOfLine( idStr &out ) {
|
|
idToken token;
|
|
|
|
out.Empty();
|
|
while( ReadToken( &token ) ) {
|
|
if ( token.linesCrossed ) {
|
|
UnreadSourceToken( token );
|
|
break;
|
|
}
|
|
if ( out.Length() ) {
|
|
out += " ";
|
|
}
|
|
out += token;
|
|
}
|
|
return out.c_str();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::UnreadToken
|
|
================
|
|
*/
|
|
void idParser::UnreadToken( const idToken& token ) {
|
|
UnreadSourceToken( token );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ReadTokenOnLine
|
|
================
|
|
*/
|
|
int idParser::ReadTokenOnLine( idToken *token ) {
|
|
idToken tok;
|
|
|
|
if ( !ReadToken( &tok ) ) {
|
|
return false;
|
|
}
|
|
// if no lines were crossed before this token
|
|
if ( !tok.linesCrossed ) {
|
|
*token = tok;
|
|
return true;
|
|
}
|
|
|
|
UnreadSourceToken( tok );
|
|
token->Clear();
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ParseInt
|
|
================
|
|
*/
|
|
int idParser::ParseInt( void ) {
|
|
idToken token;
|
|
|
|
if ( !ReadToken( &token ) ) {
|
|
Error( "couldn't read expected integer" );
|
|
return 0;
|
|
}
|
|
if ( token.type == TT_PUNCTUATION && token == "-" ) {
|
|
ExpectTokenType( TT_NUMBER, TT_INTEGER, &token );
|
|
return -((signed int) token.GetIntValue());
|
|
}
|
|
else if ( token.type != TT_NUMBER || token.subtype == TT_FLOAT ) {
|
|
Error( "expected integer value, found '%s'", token.c_str() );
|
|
}
|
|
return token.GetIntValue();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ParseBool
|
|
================
|
|
*/
|
|
bool idParser::ParseBool( void ) {
|
|
idToken token;
|
|
|
|
if ( !ExpectTokenType( TT_NUMBER, 0, &token ) ) {
|
|
Error( "couldn't read expected boolean" );
|
|
return false;
|
|
}
|
|
return ( token.GetIntValue() != 0 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::ParseFloat
|
|
================
|
|
*/
|
|
float idParser::ParseFloat( bool* hadError ) {
|
|
idToken token;
|
|
|
|
if( hadError != NULL ) {
|
|
*hadError = false;
|
|
}
|
|
|
|
if ( !ReadToken( &token ) ) {
|
|
if( hadError != NULL ) {
|
|
*hadError = true;
|
|
}
|
|
Error( "couldn't read expected floating point number" );
|
|
return 0.0f;
|
|
}
|
|
if ( token.type == TT_PUNCTUATION && token == "-" ) {
|
|
ExpectTokenType( TT_NUMBER, 0, &token );
|
|
return -token.GetFloatValue();
|
|
}
|
|
else if ( token.type != TT_NUMBER ) {
|
|
if( hadError != NULL ) {
|
|
*hadError = true;
|
|
}
|
|
Error( "expected float value, found '%s'", token.c_str() );
|
|
}
|
|
return token.GetFloatValue();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Parse1DMatrix
|
|
================
|
|
*/
|
|
int idParser::Parse1DMatrix( int x, float *m ) {
|
|
int i;
|
|
|
|
if ( !ExpectTokenString( "(" ) ) {
|
|
return false;
|
|
}
|
|
|
|
for ( i = 0; i < x; i++ ) {
|
|
m[i] = ParseFloat();
|
|
}
|
|
|
|
if ( !ExpectTokenString( ")" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Parse2DMatrix
|
|
================
|
|
*/
|
|
int idParser::Parse2DMatrix( int y, int x, float *m ) {
|
|
int i;
|
|
|
|
if ( !ExpectTokenString( "(" ) ) {
|
|
return false;
|
|
}
|
|
|
|
for ( i = 0; i < y; i++ ) {
|
|
if ( !Parse1DMatrix( x, m + i * x ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( !ExpectTokenString( ")" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::Parse3DMatrix
|
|
================
|
|
*/
|
|
int idParser::Parse3DMatrix( int z, int y, int x, float *m ) {
|
|
int i;
|
|
|
|
if ( !ExpectTokenString( "(" ) ) {
|
|
return false;
|
|
}
|
|
|
|
for ( i = 0 ; i < z; i++ ) {
|
|
if ( !Parse2DMatrix( y, x, m + i * x*y ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( !ExpectTokenString( ")" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::GetNextWhiteSpace
|
|
================
|
|
*/
|
|
int idParser::GetNextWhiteSpace( idStr &whiteSpace, bool currentLine ) {
|
|
if ( scriptstack ) {
|
|
scriptstack->GetNextWhiteSpace( whiteSpace, currentLine );
|
|
} else {
|
|
whiteSpace.Clear();
|
|
}
|
|
return whiteSpace.Length();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::GetLastWhiteSpace
|
|
================
|
|
*/
|
|
int idParser::GetLastWhiteSpace( idStr &whiteSpace ) const {
|
|
if ( scriptstack ) {
|
|
scriptstack->GetLastWhiteSpace( whiteSpace );
|
|
} else {
|
|
whiteSpace.Clear();
|
|
}
|
|
return whiteSpace.Length();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SetIncludePath
|
|
================
|
|
*/
|
|
void idParser::SetIncludePath( const char *path ) {
|
|
includepath = path;
|
|
// add trailing path seperator
|
|
if ( includepath[includepath.Length()-1] != '\\' && includepath[includepath.Length()-1] != '/' ) {
|
|
includepath += PATHSEPARATOR_STR;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SetPragmaCallback
|
|
================
|
|
*/
|
|
void idParser::SetPragmaCallback( void *data, pragmaFunc_t func ) {
|
|
pragmaCallback = func;
|
|
pragmaData = data;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SetPunctuations
|
|
================
|
|
*/
|
|
void idParser::SetPunctuations( const punctuation_t *p ) {
|
|
punctuations = p;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::GetPunctuationFromId
|
|
================
|
|
*/
|
|
const char *idParser::GetPunctuationFromId( int id ) {
|
|
int i;
|
|
|
|
if ( !punctuations ) {
|
|
idLexer lex;
|
|
return lex.GetPunctuationFromId( id );
|
|
}
|
|
|
|
for ( i = 0; punctuations[i].p; i++ ) {
|
|
if ( punctuations[i].n == id ) {
|
|
return punctuations[i].p;
|
|
}
|
|
}
|
|
return "unkown punctuation";
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::GetPunctuationId
|
|
================
|
|
*/
|
|
int idParser::GetPunctuationId( const char *p ) {
|
|
int i;
|
|
|
|
if ( punctuations == NULL ) {
|
|
idLexer lex;
|
|
return lex.GetPunctuationId( p );
|
|
}
|
|
|
|
for ( i = 0; punctuations[i].p; i++ ) {
|
|
if ( !idStr::Cmp( punctuations[i].p, p ) ) {
|
|
return punctuations[i].n;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::SetFlags
|
|
================
|
|
*/
|
|
void idParser::SetFlags( int flags ) {
|
|
idLexer *s;
|
|
|
|
this->flags = flags;
|
|
for ( s = scriptstack; s != NULL; s = s->next ) {
|
|
s->SetFlags( flags );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::GetFlags
|
|
================
|
|
*/
|
|
int idParser::GetFlags( void ) const {
|
|
return flags;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::LoadFile
|
|
================
|
|
*/
|
|
int idParser::LoadFile( const char *filename, bool OSPath, int startLine ) {
|
|
idLexer *script;
|
|
|
|
if ( loaded ) {
|
|
idLib::common->FatalError( "idParser::loadFile: another source already loaded" );
|
|
return false;
|
|
}
|
|
script = new idLexer;
|
|
script->SetFlags( this->flags );
|
|
script->SetPunctuations( this->punctuations );
|
|
if ( !script->LoadFile( filename, OSPath, startLine ) ) {
|
|
delete script;
|
|
return false;
|
|
}
|
|
script->next = NULL;
|
|
this->OSPath = OSPath;
|
|
this->filename = filename;
|
|
scriptstack = script;
|
|
tokens = NULL;
|
|
indentstack = NULL;
|
|
skip = 0;
|
|
loaded = true;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
|
|
if ( definehash == NULL ) {
|
|
defines = NULL;
|
|
definehash = (define_t **) Mem_ClearedAlloc( DEFINEHASHSIZE * sizeof(define_t *) );
|
|
AddGlobalDefinesToSource();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::LoadMemory
|
|
================
|
|
*/
|
|
int idParser::LoadMemory( const char *ptr, int length, const char *name, int startLine ) {
|
|
idLexer *script;
|
|
this->startLine = startLine;
|
|
|
|
if ( loaded ) {
|
|
idLib::common->FatalError("idParser::LoadMemory: another source already loaded");
|
|
return false;
|
|
}
|
|
script = new idLexer;
|
|
script->SetFlags( this->flags );
|
|
script->SetPunctuations( this->punctuations );
|
|
if ( !script->LoadMemory( ptr, length, name, startLine ) ) {
|
|
delete script;
|
|
return false;
|
|
}
|
|
script->next = NULL;
|
|
filename = name;
|
|
scriptstack = script;
|
|
tokens = NULL;
|
|
indentstack = NULL;
|
|
skip = 0;
|
|
loaded = true;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
|
|
if ( definehash == NULL ) {
|
|
defines = NULL;
|
|
definehash = (define_t **) Mem_ClearedAlloc( DEFINEHASHSIZE * sizeof(define_t *) );
|
|
AddGlobalDefinesToSource();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::LoadMemoryBinary
|
|
================
|
|
*/
|
|
int idParser::LoadMemoryBinary( const byte *ptr, int length, const char *name, idTokenCache* globals ) {
|
|
idLexer *script;
|
|
this->startLine = 0;
|
|
|
|
if ( loaded ) {
|
|
idLib::common->FatalError("idParser::LoadMemoryBinary: another source already loaded");
|
|
return false;
|
|
}
|
|
script = new idLexer;
|
|
script->SetFlags( this->flags );
|
|
script->SetPunctuations( this->punctuations );
|
|
if ( !script->LoadMemoryBinary( ptr, length, name, globals ) ) {
|
|
delete script;
|
|
return false;
|
|
}
|
|
|
|
script->next = NULL;
|
|
filename = name;
|
|
scriptstack = script;
|
|
tokens = NULL;
|
|
indentstack = NULL;
|
|
skip = 0;
|
|
loaded = true;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
|
|
if ( definehash == NULL ) {
|
|
defines = NULL;
|
|
definehash = (define_t **) Mem_ClearedAlloc( DEFINEHASHSIZE * sizeof(define_t *) );
|
|
AddGlobalDefinesToSource();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::FreeSource
|
|
================
|
|
*/
|
|
void idParser::FreeSource( bool keepDefines ) {
|
|
idLexer *script;
|
|
idToken *token;
|
|
define_t *define;
|
|
indent_t *indent;
|
|
int i;
|
|
|
|
dependencies.Clear();
|
|
|
|
// free all the scripts
|
|
while( scriptstack != NULL ) {
|
|
script = scriptstack;
|
|
scriptstack = scriptstack->next;
|
|
delete script;
|
|
}
|
|
// free all the tokens
|
|
while( tokens != NULL ) {
|
|
token = tokens;
|
|
tokens = tokens->next;
|
|
delete token;
|
|
}
|
|
// free all indents
|
|
while( indentstack != NULL ) {
|
|
indent = indentstack;
|
|
indentstack = indentstack->next;
|
|
Mem_Free( indent );
|
|
}
|
|
if ( !keepDefines ) {
|
|
// free hash table
|
|
if ( definehash != NULL ) {
|
|
// free defines
|
|
for ( i = 0; i < DEFINEHASHSIZE; i++ ) {
|
|
while( definehash[i] != NULL ) {
|
|
define = definehash[i];
|
|
definehash[i] = definehash[i]->hashnext;
|
|
FreeDefine( define );
|
|
}
|
|
}
|
|
defines = NULL;
|
|
Mem_Free( definehash );
|
|
definehash = NULL;
|
|
}
|
|
}
|
|
loaded = false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::idParser
|
|
================
|
|
*/
|
|
idParser::idParser() {
|
|
loaded = false;
|
|
OSPath = false;
|
|
punctuations = 0;
|
|
flags = 0;
|
|
scriptstack = NULL;
|
|
indentstack = NULL;
|
|
definehash = NULL;
|
|
defines = NULL;
|
|
tokens = NULL;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
startLine = 1;
|
|
skip = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::idParser
|
|
================
|
|
*/
|
|
idParser::idParser( int flags ) {
|
|
loaded = false;
|
|
OSPath = false;
|
|
punctuations = 0;
|
|
this->flags = flags;
|
|
scriptstack = NULL;
|
|
indentstack = NULL;
|
|
definehash = NULL;
|
|
defines = NULL;
|
|
tokens = NULL;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
startLine = 1;
|
|
skip = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::idParser
|
|
================
|
|
*/
|
|
idParser::idParser( const char *filename, int _flags, bool _OSPath ) {
|
|
loaded = false;
|
|
OSPath = _OSPath;
|
|
punctuations = 0;
|
|
flags = _flags;
|
|
scriptstack = NULL;
|
|
indentstack = NULL;
|
|
definehash = NULL;
|
|
defines = NULL;
|
|
tokens = NULL;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
startLine = 1;
|
|
skip = 0;
|
|
LoadFile( filename, OSPath );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::idParser
|
|
================
|
|
*/
|
|
idParser::idParser( const char *ptr, int length, const char *name, int flags ) {
|
|
loaded = false;
|
|
OSPath = false;
|
|
punctuations = 0;
|
|
this->flags = flags;
|
|
scriptstack = NULL;
|
|
indentstack = NULL;
|
|
definehash = NULL;
|
|
defines = NULL;
|
|
tokens = NULL;
|
|
pragmaCallback = NULL;
|
|
pragmaData = NULL;
|
|
startLine = 1;
|
|
skip = 0;
|
|
LoadMemory( ptr, length, name, startLine );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idParser::~idParser
|
|
================
|
|
*/
|
|
idParser::~idParser( void ) {
|
|
FreeSource( false );
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idParser::WriteBinary
|
|
================
|
|
*/
|
|
void idParser::WriteBinary( idFile* f, idTokenCache* tokenCache ) {
|
|
if( scriptstack != NULL ) {
|
|
idToken token;
|
|
idLexer* base = scriptstack;
|
|
|
|
int numTokens = 0;
|
|
while( ReadToken( &token ) ) {
|
|
base->GetBinary().AddToken( token, tokenCache );
|
|
numTokens++;
|
|
}
|
|
base->GetBinary().Write( f );
|
|
|
|
/*
|
|
idLib::common->DPrintf( "%s: %i total tokens\n", filename.c_str(), numTokens );
|
|
*/
|
|
|
|
base->GetBinary().SetData( NULL, tokenCache );
|
|
|
|
// dump out a text version of everything
|
|
#if 0
|
|
ResetBinaryParsing();
|
|
|
|
idStr filename = this->filename;
|
|
filename.SetFileExtension( ".bdump" );
|
|
idFile* f = idLib::fileSystem->OpenFileAppend( filename );
|
|
if( f != NULL ) {
|
|
while( ReadToken( &token ) ) {
|
|
if( token.linesCrossed ) {
|
|
f->WriteFloatString( "\n" );
|
|
}
|
|
f->WriteFloatString( "%s%s%s ", token.type == TT_STRING ? "\"" : "", token.c_str(), token.type == TT_STRING ? "\"" : "" );
|
|
}
|
|
f->WriteFloatString( "\n" );
|
|
f->WriteFloatString( "\n" );
|
|
}
|
|
idLib::fileSystem->CloseFile( f );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idParser::ResetBinaryParsing
|
|
============
|
|
*/
|
|
void idParser::ResetBinaryParsing() {
|
|
if( scriptstack == NULL ) {
|
|
return;
|
|
}
|
|
scriptstack->GetBinary().ResetParsing();
|
|
}
|