2510 lines
49 KiB
C++
2510 lines
49 KiB
C++
// Token Interpreter
|
|
//
|
|
// -- jweier
|
|
|
|
#include <direct.h> //For getcwd()
|
|
#include <conio.h> //For getch()
|
|
#include <stdio.h>
|
|
|
|
#include "Tokenizer.h"
|
|
#include "BlockStream.h"
|
|
#include "Interpreter.h"
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Table Definitions
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//FIXME: The following tables should be passed in to the interpreter for flexibility
|
|
|
|
//Symbol Table
|
|
|
|
keywordArray_t CInterpreter::m_symbolKeywords[] =
|
|
{
|
|
//Blocks
|
|
"{", TK_BLOCK_START,
|
|
"}", TK_BLOCK_END,
|
|
|
|
//Vectors
|
|
"<", TK_VECTOR_START,
|
|
">", TK_VECTOR_END,
|
|
|
|
//Groups
|
|
"(", TK_OPEN_PARENTHESIS,
|
|
")", TK_CLOSED_PARENTHESIS,
|
|
|
|
"=", TK_EQUALS,
|
|
"!", TK_NOT,
|
|
|
|
//End
|
|
"", TK_EOF,
|
|
};
|
|
|
|
keywordArray_t CInterpreter::m_conditionalKeywords[] =
|
|
{
|
|
"", TK_EOF,
|
|
};
|
|
|
|
//ID Table
|
|
|
|
keywordArray_t CInterpreter::m_IDKeywords[] =
|
|
{
|
|
"AFFECT", ID_AFFECT,
|
|
"SOUND", ID_SOUND,
|
|
"MOVE", ID_MOVE,
|
|
"ROTATE", ID_ROTATE,
|
|
"WAIT", ID_WAIT,
|
|
"SET", ID_SET,
|
|
"LOOP", ID_LOOP,
|
|
"PRINT", ID_PRINT,
|
|
"TAG", ID_TAG,
|
|
"USE", ID_USE,
|
|
"FLUSH", ID_FLUSH,
|
|
"RUN", ID_RUN,
|
|
"KILL", ID_KILL,
|
|
"REMOVE", ID_REMOVE,
|
|
"CAMERA", ID_CAMERA,
|
|
"GET", ID_GET,
|
|
"RANDOM", ID_RANDOM,
|
|
"IF", ID_IF,
|
|
"ELSE", ID_ELSE,
|
|
"REM", ID_REM,
|
|
"FLOAT", TK_FLOAT,
|
|
"VECTOR", TK_VECTOR,
|
|
"STRING", TK_STRING,
|
|
"TASK", ID_TASK,
|
|
"DO", ID_DO,
|
|
"DECLARE", ID_DECLARE,
|
|
"FREE", ID_FREE,
|
|
"DOWAIT", ID_DOWAIT,
|
|
"SIGNAL", ID_SIGNAL,
|
|
"WAITSIGNAL", ID_WAITSIGNAL,
|
|
"PLAY", ID_PLAY,
|
|
|
|
"", ID_EOF,
|
|
};
|
|
|
|
//Type Table
|
|
|
|
keywordArray_t CInterpreter::m_typeKeywords[] =
|
|
{
|
|
//Set types
|
|
"ANGLES", TYPE_ANGLES,
|
|
"ORIGIN", TYPE_ORIGIN,
|
|
|
|
//Affect types
|
|
"INSERT", TYPE_INSERT,
|
|
"FLUSH", TYPE_FLUSH,
|
|
|
|
//Get types
|
|
"FLOAT", TK_FLOAT,
|
|
"INT", TK_INT,
|
|
"VECTOR", TK_VECTOR,
|
|
"STRING", TK_STRING,
|
|
|
|
"PAN", TYPE_PAN,
|
|
"ZOOM", TYPE_ZOOM,
|
|
"MOVE", TYPE_MOVE,
|
|
"FADE", TYPE_FADE,
|
|
"PATH", TYPE_PATH,
|
|
"ENABLE", TYPE_ENABLE,
|
|
"DISABLE", TYPE_DISABLE,
|
|
"SHAKE", TYPE_SHAKE,
|
|
"ROLL", TYPE_ROLL,
|
|
"TRACK", TYPE_TRACK,
|
|
"FOLLOW", TYPE_FOLLOW,
|
|
"DISTANCE", TYPE_DISTANCE,
|
|
|
|
//End
|
|
"", TYPE_EOF,
|
|
};
|
|
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Constructor / Destructor
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
CInterpreter::CInterpreter()
|
|
{
|
|
}
|
|
|
|
CInterpreter::~CInterpreter()
|
|
{
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Error Handling
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::Error( char *format, ... )
|
|
{
|
|
va_list argptr;
|
|
char *error_file, error_msg[1024]="", work_dir[1024]="", out_msg[1024]="";
|
|
int error_line = m_iCurrentLine; // m_tokenizer->GetCurLine();
|
|
|
|
m_tokenizer->GetCurFilename( &error_file );
|
|
if (!error_file)
|
|
{
|
|
// 99% of the time we'll get here now, because of pushed parse streams
|
|
//
|
|
error_file = (char *)m_sCurrentFile.c_str();
|
|
}
|
|
|
|
va_start (argptr, format);
|
|
vsprintf (error_msg, format, argptr);
|
|
va_end (argptr);
|
|
|
|
strcpy((char *) work_dir, getcwd( (char *) &work_dir, 1024 ) );
|
|
|
|
if (error_file[1] == ':')
|
|
{
|
|
sprintf((char *) out_msg, "%s (%d) : error: %s\n", error_file, error_line, error_msg);
|
|
}
|
|
else
|
|
{
|
|
sprintf((char *) out_msg, "%s\\%s (%d) : error: %s\n", work_dir, error_file, error_line, error_msg);
|
|
}
|
|
|
|
if (m_sCurrentLine.length())
|
|
{
|
|
strcat(out_msg, "\nLine:\n\n");
|
|
strcat(out_msg, m_sCurrentLine.c_str());
|
|
strcat(out_msg, "\n");
|
|
}
|
|
|
|
#ifdef __POP_UPS__
|
|
|
|
MessageBox( NULL, out_msg, "Error", MB_OK );
|
|
|
|
#else
|
|
|
|
printf(out_msg);
|
|
|
|
#endif
|
|
|
|
// A bit of kludge code that takes care of the case where there's some garbage at the beginning of the file
|
|
// before any blocks are read as valid. This is needed because ints are incapable of containing 0
|
|
//
|
|
// This'll mean that technically it's saying block 1 is wrong, rather than the one in between them, but I can
|
|
// live with that.
|
|
//
|
|
if (m_iBadCBlockNumber == 0)
|
|
{
|
|
m_iBadCBlockNumber = 1;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Local Variable Functions
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
/*
|
|
-------------------------
|
|
InitVars
|
|
-------------------------
|
|
*/
|
|
|
|
void CInterpreter::InitVars( void )
|
|
{
|
|
m_vars.clear();
|
|
m_varMap.clear();
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FreeVars
|
|
-------------------------
|
|
*/
|
|
|
|
void CInterpreter::FreeVars( void )
|
|
{
|
|
variable_v::iterator vi;
|
|
|
|
for ( vi = m_vars.begin(); vi != m_vars.end(); vi++ )
|
|
{
|
|
delete (*vi);
|
|
}
|
|
|
|
InitVars();
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
AddVar
|
|
-------------------------
|
|
*/
|
|
|
|
variable_t *CInterpreter::AddVar( const char *name, int type )
|
|
{
|
|
variable_t *var;
|
|
|
|
var = new variable_t;
|
|
|
|
if ( var == NULL )
|
|
return NULL;
|
|
|
|
//Specify the type
|
|
var->type = type;
|
|
|
|
//Retain the name internally
|
|
strncpy( (char *) var->name, name, MAX_VAR_NAME );
|
|
|
|
//Associate it
|
|
m_varMap[ name ] = var;
|
|
|
|
return var;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FindVar
|
|
-------------------------
|
|
*/
|
|
|
|
variable_t *CInterpreter::FindVar( const char *name )
|
|
{
|
|
variable_m::iterator vmi;
|
|
|
|
vmi = m_varMap.find( name );
|
|
|
|
if ( vmi == m_varMap.end() )
|
|
return NULL;
|
|
|
|
return (*vmi).second;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetVariable
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetVariable( int type )
|
|
{
|
|
const char *varName;
|
|
variable_t *var;
|
|
CToken *token;
|
|
|
|
//Get the variable's name
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
varName = token->GetStringValue();
|
|
|
|
//See if we already have a variable by this name
|
|
var = FindVar( varName );
|
|
|
|
//Variable names must be unique on creation
|
|
if ( var )
|
|
return Error( "\"%s\" : already exists\n", varName );
|
|
|
|
//Add the variable
|
|
AddVar( varName, type );
|
|
|
|
//Insert the variable into the stream
|
|
|
|
CBlock block;
|
|
|
|
block.Create( TYPE_VARIABLE );
|
|
block.Write( TK_FLOAT, (float) type );
|
|
block.Write( TK_STRING, varName );
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
token->Delete();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
ID Table Functions
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetVector( CBlock *block )
|
|
{
|
|
//Look for a tag
|
|
if ( MatchTag() )
|
|
{
|
|
return GetTag( block );
|
|
}
|
|
|
|
//Look for a get
|
|
if ( MatchGet() )
|
|
{
|
|
return GetGet( block );
|
|
}
|
|
|
|
if ( Match( TK_VECTOR_START ) )
|
|
{
|
|
//Get the vector
|
|
block->Write( TK_VECTOR, (float) TK_VECTOR );
|
|
|
|
for (int i=0; i<3; i++)
|
|
GetFloat( block );
|
|
|
|
if (!Match( TK_VECTOR_END ))
|
|
{
|
|
return Error("syntax error : expected end of vector");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
MatchTag()
|
|
|
|
Attempts to match to a tag identifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::MatchTag( void )
|
|
{
|
|
CToken *token;
|
|
const char *idName;
|
|
int id;
|
|
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
idName = token->GetStringValue();
|
|
id = FindSymbol( idName, m_IDKeywords );
|
|
|
|
if ( id != ID_TAG )
|
|
{
|
|
//Return the token
|
|
m_tokenizer->PutBackToken( token );
|
|
return false;
|
|
}
|
|
|
|
token->Delete();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
MatchGet()
|
|
|
|
Attempts to match to a get identifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::MatchGet( void )
|
|
{
|
|
CToken *token;
|
|
const char *idName;
|
|
int id;
|
|
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
idName = token->GetStringValue();
|
|
id = FindSymbol( idName, m_IDKeywords );
|
|
|
|
if ( id != ID_GET )
|
|
{
|
|
//Return the token
|
|
m_tokenizer->PutBackToken( token );
|
|
return false;
|
|
}
|
|
|
|
token->Delete();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
MatchRandom()
|
|
|
|
Attempts to match to a random identifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::MatchRandom( void )
|
|
{
|
|
CToken *token;
|
|
const char *idName;
|
|
int id;
|
|
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
idName = token->GetStringValue();
|
|
id = FindSymbol( idName, m_IDKeywords );
|
|
|
|
if ( id != ID_RANDOM )
|
|
{
|
|
//Return the token
|
|
m_tokenizer->PutBackToken( token );
|
|
return false;
|
|
}
|
|
|
|
token->Delete();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
FindSymbol()
|
|
|
|
Searches the symbol table for the given name. Returns the ID if found.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::FindSymbol( const char *name, keywordArray_t *table)
|
|
{
|
|
keywordArray_t *ids;
|
|
|
|
for (ids = table; (strcmp(ids->m_keyword, "")); ids++)
|
|
{
|
|
if (!stricmp(name, ids->m_keyword))
|
|
return ids->m_tokenvalue;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Match()
|
|
|
|
Looks ahead to the next token to try and match it to the passed token, consumes token on success.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//NOTENOTE: LookAhead() was separated from Match() for clarity
|
|
|
|
int CInterpreter::Match( int token_id )
|
|
{
|
|
CToken *token;
|
|
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
|
|
if ( token->GetType() != token_id )
|
|
{
|
|
//This may have been a check, so don't loose the token
|
|
m_tokenizer->PutBackToken( token );
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetNextType
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetNextType( void )
|
|
{
|
|
CToken *token = m_tokenizer->GetToken( 0, 0 );
|
|
int id = token->GetType();
|
|
|
|
m_tokenizer->PutBackToken( token );
|
|
|
|
return id;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
LookAhead()
|
|
|
|
Looks ahead without consuming on success.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::LookAhead( int token_id )
|
|
{
|
|
CToken *token;
|
|
|
|
token = m_tokenizer->GetToken( 0, 0 );
|
|
|
|
if ( token->GetType() != token_id )
|
|
{
|
|
m_tokenizer->PutBackToken( token );
|
|
|
|
return false;
|
|
}
|
|
|
|
m_tokenizer->PutBackToken( token );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetTokenName()
|
|
|
|
Returns the name of a token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
const char *CInterpreter::GetTokenName( int token_id )
|
|
{
|
|
switch ( token_id )
|
|
{
|
|
case TK_STRING:
|
|
return "STRING";
|
|
break;
|
|
|
|
case TK_CHAR:
|
|
return "CHARACTER";
|
|
break;
|
|
|
|
case TK_IDENTIFIER:
|
|
return "IDENTIFIER";
|
|
break;
|
|
|
|
case TK_FLOAT:
|
|
return "FLOAT";
|
|
break;
|
|
|
|
case TK_INTEGER:
|
|
return "INTEGER";
|
|
break;
|
|
|
|
default:
|
|
return "UNKNOWN";
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Token Value Functions
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetFloat()
|
|
|
|
Attempts to match and retrieve the value of a float token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetFloat( CBlock *block )
|
|
{
|
|
CToken *token;
|
|
int type;
|
|
|
|
//Look for a get
|
|
if ( MatchGet() )
|
|
{
|
|
return GetGet( block );
|
|
}
|
|
|
|
//Look for a random
|
|
if ( MatchRandom() )
|
|
{
|
|
return GetRandom( block );
|
|
}
|
|
|
|
token = m_tokenizer->GetToken(0,0);
|
|
type = token->GetType();
|
|
|
|
//Floats can accept either int or float values
|
|
if ( ( type != TK_FLOAT ) && ( type != TK_INT ) )
|
|
{
|
|
return Error("syntax error : expected float; found %s", GetTokenName(type) );
|
|
}
|
|
|
|
if (type == TK_FLOAT)
|
|
{
|
|
block->Write( TK_FLOAT, (float) token->GetFloatValue() );
|
|
}
|
|
else
|
|
{
|
|
block->Write( TK_FLOAT, (float) token->GetIntValue() );
|
|
}
|
|
|
|
token->Delete();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetInteger()
|
|
|
|
Attempts to match and retrieve the value of an integer token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetInteger( CBlock *block )
|
|
{
|
|
return GetFloat( block );
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetString()
|
|
|
|
Attempts to match and retrieve the value of a string token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetString( CBlock *block )
|
|
{
|
|
CToken *token;
|
|
int type;
|
|
|
|
//Look for a get
|
|
if ( MatchGet() )
|
|
{
|
|
return GetGet( block );
|
|
}
|
|
|
|
//Look for a random
|
|
if ( MatchRandom() )
|
|
{
|
|
return GetRandom( block );
|
|
}
|
|
|
|
token = m_tokenizer->GetToken(0, 0);
|
|
type = token->GetType();
|
|
|
|
if ( (type != TK_STRING) && (type != TK_CHAR) )
|
|
{
|
|
return Error("syntax error : expected string; found %s", GetTokenName(type));
|
|
}
|
|
|
|
//UGLY HACK!!!
|
|
|
|
const char *temptr;
|
|
char temp[1024];
|
|
|
|
temptr = token->GetStringValue();
|
|
|
|
if ( strlen(temptr)+1 > sizeof( temp ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for ( int i = 0; i < strlen( temptr ); i++ )
|
|
{
|
|
if ( temptr[i] == '#' )
|
|
temp[i] = '\n';
|
|
else
|
|
temp[i] = temptr[i];
|
|
}
|
|
|
|
temp[ strlen( temptr ) ] = 0;
|
|
|
|
//UGLY HACK END!!!
|
|
|
|
block->Write( TK_STRING, (const char *) &temp );
|
|
|
|
token->Delete();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetIdentifier()
|
|
|
|
Attempts to match and retrieve the value of an indentifier token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetIdentifier( CBlock *block )
|
|
{
|
|
CToken *token;
|
|
int type;
|
|
|
|
//FIXME: Should identifiers do this?
|
|
if ( MatchGet() )
|
|
{
|
|
if ( GetGet( block ) == false )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
token = m_tokenizer->GetToken(0, 0);
|
|
type = token->GetType();
|
|
|
|
if ( type != TK_IDENTIFIER )
|
|
{
|
|
return Error("syntax error : expected indentifier; found %s", GetTokenName(type));
|
|
}
|
|
|
|
block->Write( TK_IDENTIFIER, (const char *) token->GetStringValue() );
|
|
|
|
token->Delete();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetEvaluator()
|
|
|
|
Attempts to match and retrieve the value of an evaluator token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetEvaluator( CBlock *block )
|
|
{
|
|
CToken *token;
|
|
int type;
|
|
|
|
if ( MatchGet() )
|
|
return false;
|
|
|
|
if ( MatchRandom() )
|
|
return false;
|
|
|
|
token = m_tokenizer->GetToken(0, 0);
|
|
type = token->GetType();
|
|
token->Delete();
|
|
|
|
switch ( type )
|
|
{
|
|
case TK_GREATER_THAN:
|
|
case TK_LESS_THAN:
|
|
case TK_EQUALS:
|
|
case TK_NOT:
|
|
break;
|
|
|
|
case TK_VECTOR_START:
|
|
type = TK_LESS_THAN;
|
|
break;
|
|
|
|
case TK_VECTOR_END:
|
|
type = TK_GREATER_THAN;
|
|
break;
|
|
|
|
default:
|
|
return Error("syntax error : expected operator type, found %s", GetTokenName( type ) );
|
|
}
|
|
|
|
block->Write( type, 0 );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetAny()
|
|
|
|
Attempts to match and retrieve any valid data type.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetAny( CBlock *block )
|
|
{
|
|
CToken *token;
|
|
int type;
|
|
|
|
if ( MatchGet() )
|
|
{
|
|
if ( GetGet( block ) == false )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
if ( MatchRandom() )
|
|
{
|
|
if ( GetRandom( block ) == false )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
if ( MatchTag() )
|
|
{
|
|
if ( GetTag( block ) == false )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
token = m_tokenizer->GetToken(0, 0);
|
|
type = token->GetType();
|
|
|
|
switch ( type )
|
|
{
|
|
case TK_FLOAT:
|
|
m_tokenizer->PutBackToken( token );
|
|
if ( GetFloat( block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_INT:
|
|
m_tokenizer->PutBackToken( token );
|
|
if ( GetInteger( block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_VECTOR_START:
|
|
m_tokenizer->PutBackToken( token );
|
|
if ( GetVector( block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_STRING:
|
|
case TK_CHAR:
|
|
m_tokenizer->PutBackToken( token );
|
|
if ( GetString( block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_IDENTIFIER:
|
|
m_tokenizer->PutBackToken( token );
|
|
if ( GetIdentifier( block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetType()
|
|
|
|
Attempts to match and retrieve the value of a type token.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetType( char *get )
|
|
{
|
|
CToken *token;
|
|
char *string;
|
|
int type;
|
|
|
|
token = m_tokenizer->GetToken(0, 0);
|
|
type = token->GetType();
|
|
|
|
if ( type != TK_IDENTIFIER )
|
|
{
|
|
return Error("syntax error : expected identifier; found %s", GetTokenName(type));
|
|
}
|
|
|
|
string = (char *) token->GetStringValue();
|
|
|
|
if ( (strlen(string) + 1) > MAX_STRING_LENGTH)
|
|
{
|
|
Error("string exceeds 256 character limit");
|
|
return false;
|
|
}
|
|
|
|
strcpy(get, string);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetID()
|
|
|
|
Attempts to match and interpret an identifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//FIXME: This should use an externally defined table to match ID and functions
|
|
|
|
int CInterpreter::GetID( char *id_name )
|
|
{
|
|
int id;
|
|
|
|
id = FindSymbol( id_name, m_IDKeywords );
|
|
|
|
if ( id == -1 )
|
|
return Error("'%s' : unknown identifier", id_name);
|
|
|
|
//FIXME: Function pointers would be awfully nice.. but not inside a class! Weee!!
|
|
|
|
switch (id)
|
|
{
|
|
|
|
//Affect takes control of an entity
|
|
|
|
case ID_AFFECT:
|
|
return GetAffect();
|
|
break;
|
|
|
|
//Wait for a specified amount of time
|
|
|
|
case ID_WAIT:
|
|
return GetWait();
|
|
break;
|
|
|
|
//Generic set call
|
|
|
|
case ID_SET:
|
|
return GetSet();
|
|
break;
|
|
|
|
case ID_LOOP:
|
|
return GetLoop();
|
|
break;
|
|
|
|
case ID_PRINT:
|
|
return GetPrint();
|
|
break;
|
|
|
|
case ID_USE:
|
|
return GetUse();
|
|
break;
|
|
|
|
case ID_FLUSH:
|
|
return GetFlush();
|
|
break;
|
|
|
|
case ID_RUN:
|
|
return GetRun();
|
|
break;
|
|
|
|
case ID_KILL:
|
|
return GetKill();
|
|
break;
|
|
|
|
case ID_REMOVE:
|
|
return GetRemove();
|
|
break;
|
|
|
|
case ID_CAMERA:
|
|
return GetCamera();
|
|
break;
|
|
|
|
case ID_SOUND:
|
|
return GetSound();
|
|
break;
|
|
|
|
case ID_MOVE:
|
|
return GetMove();
|
|
break;
|
|
|
|
case ID_ROTATE:
|
|
return GetRotate();
|
|
break;
|
|
|
|
case ID_IF:
|
|
return GetIf();
|
|
break;
|
|
|
|
case ID_ELSE:
|
|
//return Error("syntax error : else without matching if");
|
|
return GetElse(); //FIXME: Protect this call so that floating else's aren't allowed
|
|
break;
|
|
|
|
case ID_GET:
|
|
return Error("syntax error : illegal use of \"get\"");
|
|
break;
|
|
|
|
case ID_TAG:
|
|
return Error("syntax error : illegal use of \"tag\"");
|
|
break;
|
|
|
|
case ID_TASK:
|
|
return GetTask();
|
|
break;
|
|
|
|
case ID_DO:
|
|
return GetDo();
|
|
break;
|
|
|
|
case ID_DECLARE:
|
|
return GetDeclare();
|
|
break;
|
|
|
|
case ID_FREE:
|
|
return GetFree();
|
|
break;
|
|
|
|
case ID_REM:
|
|
GetRem();
|
|
break;
|
|
|
|
case ID_DOWAIT:
|
|
GetDoWait();
|
|
break;
|
|
|
|
case ID_SIGNAL:
|
|
GetSignal();
|
|
break;
|
|
|
|
case ID_WAITSIGNAL:
|
|
GetWaitSignal();
|
|
break;
|
|
|
|
case ID_PLAY:
|
|
GetPlay(); //Bad eighties slang joke... yeah, it's not really funny, I know...
|
|
break;
|
|
|
|
//Local variable types
|
|
case TK_FLOAT:
|
|
case TK_INT:
|
|
case TK_STRING:
|
|
case TK_VECTOR:
|
|
GetVariable( id );
|
|
break;
|
|
|
|
//Unknown ID
|
|
|
|
default:
|
|
case -1:
|
|
return Error("'%s' : unknown identifier", id_name);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
ID Interpreting Functions
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
/*
|
|
-------------------------
|
|
GetDeclare
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetDeclare( void )
|
|
{
|
|
CBlock block;
|
|
char typeName[MAX_STRING_LENGTH];
|
|
int type;
|
|
|
|
block.Create( ID_DECLARE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetType( (char *) typeName ) == false )
|
|
return false;
|
|
|
|
type = FindSymbol( typeName, m_typeKeywords);
|
|
|
|
switch ( type )
|
|
{
|
|
case TK_FLOAT:
|
|
case TK_VECTOR:
|
|
case TK_STRING:
|
|
block.Write( TK_FLOAT, (float) type );
|
|
break;
|
|
|
|
default:
|
|
return Error("unknown identifier %s", typeName );
|
|
break;
|
|
}
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("declare : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
-------------------------
|
|
GetFree
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetFree( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_FREE );
|
|
|
|
if ( Match( TK_OPEN_PARENTHESIS ) == false )
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if ( Match( TK_CLOSED_PARENTHESIS ) == false )
|
|
return Error("free : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetIf()
|
|
|
|
Handles the if() conditional statement.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// if ( STRING ? STRING )
|
|
|
|
int CInterpreter::GetIf( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_IF );
|
|
|
|
if ( Match( TK_OPEN_PARENTHESIS ) == false )
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetAny( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetEvaluator( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetAny( &block ) == false )
|
|
return false;
|
|
|
|
if ( Match( TK_CLOSED_PARENTHESIS ) == false )
|
|
return Error("if : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetElse()
|
|
|
|
Handles the else() conditional statement.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// else
|
|
|
|
int CInterpreter::GetElse( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_ELSE );
|
|
|
|
/*
|
|
if ( Match( TK_OPEN_PARENTHESIS ) == false )
|
|
return Error("syntax error : '(' not found");
|
|
*/
|
|
|
|
/*
|
|
if ( GetAny( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetEvaluator( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetAny( &block ) == false )
|
|
return false;
|
|
*/
|
|
|
|
/*
|
|
if ( Match( TK_CLOSED_PARENTHESIS ) == false )
|
|
return Error("sound : too many parameters");
|
|
*/
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetTask()
|
|
|
|
Handles the task() sequence specifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//task ( name ) { }
|
|
|
|
int CInterpreter::GetTask( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_TASK );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("GetTask: too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetDo()
|
|
|
|
Handles the do() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//do ( taskName )
|
|
|
|
int CInterpreter::GetDo( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_DO );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("do : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetGet()
|
|
|
|
Handles the get() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// get( TYPE, NAME );
|
|
|
|
int CInterpreter::GetGet( CBlock *block )
|
|
{
|
|
char typeName[MAX_STRING_LENGTH];
|
|
int type;
|
|
|
|
block->Write( ID_GET, (float) ID_GET );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetType( (char *) typeName ) == false )
|
|
return false;
|
|
|
|
type = FindSymbol( typeName, m_typeKeywords);
|
|
|
|
switch ( type )
|
|
{
|
|
case TK_FLOAT:
|
|
case TK_INT:
|
|
case TK_VECTOR:
|
|
case TK_STRING:
|
|
block->Write( TK_FLOAT, (float) type );
|
|
break;
|
|
|
|
default:
|
|
return Error("unknown identifier %s", typeName );
|
|
break;
|
|
}
|
|
|
|
if ( GetString( block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("affect : too many parameters");
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetRandom()
|
|
|
|
Handles the random() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
#define Q3_INFINITE 16777216
|
|
|
|
|
|
// random( low, high );
|
|
|
|
int CInterpreter::GetRandom( CBlock *block )
|
|
{
|
|
block->Write( ID_RANDOM, (float) Q3_INFINITE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetFloat( block ) == false )
|
|
return false;
|
|
|
|
if ( GetFloat( block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("affect : too many parameters");
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetSound()
|
|
|
|
Handles the sound() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// sound( NAME );
|
|
|
|
int CInterpreter::GetSound( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_SOUND );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetIdentifier( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("sound : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetMove()
|
|
|
|
Handles the move() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// move( ORIGIN, ANGLES, DURATION );
|
|
|
|
int CInterpreter::GetMove( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_MOVE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
//Angles are optional
|
|
if ( LookAhead( TK_VECTOR_START ) || LookAhead( TK_IDENTIFIER ) )
|
|
{
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
}
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("move : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetRotate()
|
|
|
|
Handles the rotate() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// move( ANGLES, DURATION );
|
|
|
|
int CInterpreter::GetRotate( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_ROTATE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("move : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetAffect()
|
|
|
|
Handles the affect() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//FIXME: This should be externally defined
|
|
|
|
int CInterpreter::GetAffect( void )
|
|
{
|
|
CBlock block;
|
|
char typeName[MAX_STRING_SIZE];
|
|
int type;
|
|
|
|
block.Create( ID_AFFECT );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!LookAhead( TK_IDENTIFIER ))
|
|
return Error("syntax error : identifier not found");
|
|
|
|
if ( MatchGet() )
|
|
return Error("syntax error : illegal use of \"get\"");
|
|
|
|
if ( GetType( (char *) typeName ) == false )
|
|
return false;
|
|
|
|
type = FindSymbol( typeName, m_typeKeywords);
|
|
|
|
switch ( type )
|
|
{
|
|
case TYPE_INSERT:
|
|
case TYPE_FLUSH:
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
break;
|
|
|
|
default:
|
|
return Error("'%s': unknown affect type", typeName );
|
|
break;
|
|
|
|
}
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("affect : too many parameters");
|
|
|
|
if (!LookAhead( TK_BLOCK_START ))
|
|
return Error("syntax error : '{' not found");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetWait()
|
|
|
|
Handles the wait() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//FIXME: This should be externally defined
|
|
|
|
int CInterpreter::GetWait( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_WAIT );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( LookAhead( TK_STRING ) )
|
|
{
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
}
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("wait : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetSet()
|
|
|
|
Handles the set() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//FIXME: This should be externally defined
|
|
|
|
int CInterpreter::GetSet( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_SET );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
//Check for get placement
|
|
if ( MatchGet() )
|
|
{
|
|
if ( GetGet( &block ) == false )
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
switch( GetNextType() )
|
|
{
|
|
case TK_INT:
|
|
|
|
if ( GetInteger( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_FLOAT:
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_STRING:
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TK_VECTOR_START:
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if ( MatchTag() )
|
|
{
|
|
GetTag( &block );
|
|
break;
|
|
}
|
|
|
|
if ( MatchRandom() )
|
|
{
|
|
GetRandom( &block );
|
|
break;
|
|
}
|
|
|
|
return Error("unknown parameter type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("set : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetLoop()
|
|
|
|
Handles the loop() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetLoop( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_LOOP );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( LookAhead( TK_CLOSED_PARENTHESIS ) )
|
|
{
|
|
//-1 denotes an infinite loop
|
|
block.Write( TK_FLOAT, (float) -1);
|
|
}
|
|
else
|
|
{
|
|
if ( GetInteger( &block ) == false )
|
|
return false;
|
|
}
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("GetLoop : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetPrint()
|
|
|
|
Handles the print() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetPrint( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_PRINT );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("print : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetUse()
|
|
|
|
Handles the use() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetUse( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_USE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("use : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetFlush()
|
|
|
|
Handles the flush() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetFlush( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_FLUSH );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("flush : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetRun()
|
|
|
|
Handles the run() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetRun( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_RUN );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("run : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetKill()
|
|
|
|
Handles the kill() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetKill( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_KILL );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("kill : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetRemove()
|
|
|
|
Handles the remove() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetRemove( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_REMOVE );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("remove : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetRem()
|
|
|
|
Handles the rem() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// this is just so people can put comments in scripts in BehavEd and not have them lost as normal comments would be.
|
|
//
|
|
int CInterpreter::GetRem( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_REM );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
// optional string?
|
|
|
|
if (Match( TK_CLOSED_PARENTHESIS ))
|
|
return true;
|
|
|
|
GetString( &block );
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("rem : function only takes 1 optional parameter");
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetCamera()
|
|
|
|
Handles the camera() function.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
int CInterpreter::GetCamera( void )
|
|
{
|
|
CBlock block;
|
|
char typeName[MAX_STRING_SIZE];
|
|
int type;
|
|
|
|
block.Create( ID_CAMERA );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetType( (char *) typeName ) == false )
|
|
return false;
|
|
|
|
type = FindSymbol( typeName, m_typeKeywords);
|
|
|
|
switch ( type )
|
|
{
|
|
case TYPE_PAN: //PAN ( ANGLES, DURATION )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_ZOOM: //ZOOM ( FOV, DURATION )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_MOVE: //MOVE ( ORIGIN, DURATION )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_FADE: //FADE ( SOURCE(R,G,B,A), DEST(R,G,B,A), DURATION )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Source color
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Dest color
|
|
if ( GetVector( &block ) == false )
|
|
return false;
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Duration
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_PATH: //PATH ( FILENAME )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Filename
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_ENABLE:
|
|
case TYPE_DISABLE:
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
break;
|
|
|
|
case TYPE_SHAKE: //SHAKE ( INTENSITY, DURATION )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Intensity
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Duration
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_ROLL: //ROLL ( ANGLE, TIME )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Angle
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Time
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_TRACK: //TRACK ( TARGETNAME, SPEED, INITLERP )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Target name
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
//Speed
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Init lerp
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_FOLLOW: //FOLLOW ( CAMERAGROUP, SPEED, INITLERP )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Camera group
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
//Speed
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Init lerp
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
|
|
case TYPE_DISTANCE: //DISTANCE ( DISTANCE, INITLERP )
|
|
|
|
block.Write( TK_FLOAT, (float) type );
|
|
|
|
//Distance
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
//Init lerp
|
|
if ( GetFloat( &block ) == false )
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("camera : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetDoWait
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetDoWait( void )
|
|
{
|
|
CBlock block;
|
|
|
|
//Write out the "do" portion
|
|
block.Create( ID_DO );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("do : too many parameters");
|
|
|
|
//Write out the accompanying "wait"
|
|
char *str = (char *) block.GetMemberData( 0 );
|
|
|
|
CBlock block2;
|
|
|
|
block2.Create( ID_WAIT );
|
|
|
|
block2.Write( TK_STRING, (char *) str );
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
m_blockStream->WriteBlock( &block2 );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetSignal
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetSignal( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_SIGNAL );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("signal : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetSignal
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetWaitSignal( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_WAITSIGNAL );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("waitsignal : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
GetPlay
|
|
-------------------------
|
|
*/
|
|
|
|
int CInterpreter::GetPlay( void )
|
|
{
|
|
CBlock block;
|
|
|
|
block.Create( ID_PLAY );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if ( GetString( &block ) == false )
|
|
return false;
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("waitsignal : too many parameters");
|
|
|
|
m_blockStream->WriteBlock( &block );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
GetTag()
|
|
|
|
Handles the tag() identifier.
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
//NOTENOTE: The tag's information is included as block members, not as a separate block.
|
|
|
|
int CInterpreter::GetTag( CBlock *block )
|
|
{
|
|
char typeName[MAX_STRING_SIZE];
|
|
int typeID;
|
|
|
|
//Mark as a tag
|
|
block->Write( ID_TAG, (float) ID_TAG );
|
|
|
|
if (!Match( TK_OPEN_PARENTHESIS ))
|
|
return Error("syntax error : '(' not found");
|
|
|
|
//Get the tag name
|
|
if ( GetString( block ) == false )
|
|
return false;
|
|
|
|
//Get the lookup ID
|
|
GetType( (char *) typeName );
|
|
|
|
typeID = FindSymbol( (char *) typeName, m_typeKeywords);
|
|
|
|
//Tags only contain origin and angles lookups
|
|
if ( (typeID != TYPE_ORIGIN) && (typeID != TYPE_ANGLES) )
|
|
{
|
|
return Error("syntax error : 'tag' : %s is not a valid look up identifier", typeName );
|
|
}
|
|
|
|
block->Write( TK_FLOAT, (float) typeID );
|
|
|
|
if (!Match( TK_CLOSED_PARENTHESIS ))
|
|
return Error("tag : too many parameters");
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
Interpret function
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
// note new return type, this now returns the bad block number, else 0 for success.
|
|
//
|
|
// I also return -ve block numbers for errors between blocks. Eg if you read 3 good blocks, then find an unexpected
|
|
// float in the script between blocks 3 & 4 then I return -3 to indicate the error is after that, but not block 4
|
|
//
|
|
int CInterpreter::Interpret( CTokenizer *Tokenizer, CBlockStream *BlockStream, char *filename )
|
|
{
|
|
CBlock block;
|
|
CToken *token;
|
|
int type, blockLevel = 0, parenthesisLevel = 0;
|
|
|
|
m_sCurrentFile = filename; // used during error reporting because you can't ask tokenizer for pushed streams
|
|
|
|
m_tokenizer = Tokenizer;
|
|
m_blockStream = BlockStream;
|
|
|
|
m_iCurrentLine = m_tokenizer->GetCurLine();
|
|
token = m_tokenizer->GetToEndOfLine(TK_STRING);
|
|
m_sCurrentLine = token->GetStringValue();
|
|
m_tokenizer->PutBackToken(token, false, NULL, true);
|
|
|
|
m_iBadCBlockNumber = 0;
|
|
|
|
while (m_tokenizer->GetRemainingSize() > 0)
|
|
{
|
|
token = m_tokenizer->GetToken( TKF_USES_EOL, 0 );
|
|
type = token->GetType();
|
|
|
|
switch ( type )
|
|
{
|
|
case TK_UNDEFINED:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("%d : undefined token", type);
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
|
|
case TK_EOF:
|
|
break;
|
|
|
|
case TK_EOL:
|
|
// read the next line, then put it back
|
|
token->Delete();
|
|
m_iCurrentLine = m_tokenizer->GetCurLine();
|
|
token = m_tokenizer->GetToEndOfLine(TK_STRING);
|
|
m_sCurrentLine = token->GetStringValue();
|
|
m_tokenizer->PutBackToken(token, false, NULL, true);
|
|
break;
|
|
|
|
case TK_CHAR:
|
|
case TK_STRING:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : unexpected string");
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
|
|
case TK_INT:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : unexpected integer");
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
|
|
case TK_FLOAT:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : unexpected float");
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
|
|
case TK_IDENTIFIER:
|
|
m_iBadCBlockNumber++;
|
|
if (!GetID( (char *) token->GetStringValue() ))
|
|
{
|
|
token->Delete();
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
token->Delete();
|
|
break;
|
|
|
|
case TK_BLOCK_START:
|
|
token->Delete();
|
|
if (parenthesisLevel)
|
|
{
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : brace inside parenthesis");
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
|
|
blockLevel++;
|
|
break;
|
|
|
|
case TK_BLOCK_END:
|
|
token->Delete();
|
|
if (parenthesisLevel)
|
|
{
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : brace inside parenthesis");
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
|
|
block.Create( ID_BLOCK_END );
|
|
m_blockStream->WriteBlock( &block );
|
|
block.Free();
|
|
|
|
blockLevel--;
|
|
break;
|
|
|
|
case TK_OPEN_PARENTHESIS:
|
|
token->Delete();
|
|
blockLevel++;
|
|
parenthesisLevel++;
|
|
break;
|
|
|
|
case TK_CLOSED_PARENTHESIS:
|
|
token->Delete();
|
|
blockLevel--;
|
|
parenthesisLevel--;
|
|
|
|
if (parenthesisLevel<0)
|
|
{
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : closed parenthesis with no opening match");
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
break;
|
|
|
|
case TK_VECTOR_START:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : unexpected vector");
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
|
|
case TK_VECTOR_END:
|
|
token->Delete();
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("syntax error : unexpected vector");
|
|
return m_iBadCBlockNumber;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( blockLevel )
|
|
{
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("error : open brace was not closed");
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
|
|
if ( parenthesisLevel )
|
|
{
|
|
m_iBadCBlockNumber = -m_iBadCBlockNumber;
|
|
Error("error: open parenthesis");
|
|
return m_iBadCBlockNumber;
|
|
}
|
|
|
|
//Release all the variable information, because it's already been written out
|
|
FreeVars();
|
|
|
|
m_iBadCBlockNumber = 0;
|
|
return m_iBadCBlockNumber; //true;
|
|
}
|
|
|