AngelscriptDebuggerServer/TestRunner/angelscript_addons/scriptbuilder/scriptbuilder.cpp

1168 lines
30 KiB
C++

#include "scriptbuilder.h"
#include <vector>
#include <assert.h>
using namespace std;
#include <stdio.h>
#if defined(_MSC_VER) && !defined(_WIN32_WCE) && !defined(__S3E__)
#include <direct.h>
#endif
#ifdef _WIN32_WCE
#include <windows.h> // For GetModuleFileName()
#endif
#if defined(__S3E__) || defined(__APPLE__) || defined(__GNUC__)
#include <unistd.h> // For getcwd()
#endif
BEGIN_AS_NAMESPACE
// Helper functions
static string GetCurrentDir();
static string GetAbsolutePath(const string &path);
CScriptBuilder::CScriptBuilder()
{
engine = 0;
module = 0;
includeCallback = 0;
includeParam = 0;
pragmaCallback = 0;
pragmaParam = 0;
}
void CScriptBuilder::SetIncludeCallback(INCLUDECALLBACK_t callback, void *userParam)
{
includeCallback = callback;
includeParam = userParam;
}
void CScriptBuilder::SetPragmaCallback(PRAGMACALLBACK_t callback, void *userParam)
{
pragmaCallback = callback;
pragmaParam = userParam;
}
int CScriptBuilder::StartNewModule(asIScriptEngine *inEngine, const char *moduleName)
{
if(inEngine == 0 ) return -1;
engine = inEngine;
module = inEngine->GetModule(moduleName, asGM_ALWAYS_CREATE);
if( module == 0 )
return -1;
ClearAll();
return 0;
}
asIScriptEngine *CScriptBuilder::GetEngine()
{
return engine;
}
asIScriptModule *CScriptBuilder::GetModule()
{
return module;
}
unsigned int CScriptBuilder::GetSectionCount() const
{
return (unsigned int)(includedScripts.size());
}
string CScriptBuilder::GetSectionName(unsigned int idx) const
{
if( idx >= includedScripts.size() ) return "";
#ifdef _WIN32
set<string, ci_less>::const_iterator it = includedScripts.begin();
#else
set<string>::const_iterator it = includedScripts.begin();
#endif
while( idx-- > 0 ) it++;
return *it;
}
// Returns 1 if the section was included
// Returns 0 if the section was not included because it had already been included before
// Returns <0 if there was an error
int CScriptBuilder::AddSectionFromFile(const char *filename)
{
// The file name stored in the set should be the fully resolved name because
// it is possible to name the same file in multiple ways using relative paths.
string fullpath = GetAbsolutePath(filename);
if( IncludeIfNotAlreadyIncluded(fullpath.c_str()) )
{
int r = LoadScriptSection(fullpath.c_str());
if( r < 0 )
return r;
else
return 1;
}
return 0;
}
// Returns 1 if the section was included
// Returns 0 if the section was not included because it had already been included before
// Returns <0 if there was an error
int CScriptBuilder::AddSectionFromMemory(const char *sectionName, const char *scriptCode, unsigned int scriptLength, int lineOffset)
{
if( IncludeIfNotAlreadyIncluded(sectionName) )
{
int r = ProcessScriptSection(scriptCode, scriptLength, sectionName, lineOffset);
if( r < 0 )
return r;
else
return 1;
}
return 0;
}
int CScriptBuilder::BuildModule()
{
return Build();
}
void CScriptBuilder::DefineWord(const char *word)
{
string sword = word;
if( definedWords.find(sword) == definedWords.end() )
{
definedWords.insert(sword);
}
}
void CScriptBuilder::ClearAll()
{
includedScripts.clear();
#if AS_PROCESS_METADATA == 1
currentClass = "";
currentNamespace = "";
foundDeclarations.clear();
typeMetadataMap.clear();
funcMetadataMap.clear();
varMetadataMap.clear();
#endif
}
bool CScriptBuilder::IncludeIfNotAlreadyIncluded(const char *filename)
{
string scriptFile = filename;
if( includedScripts.find(scriptFile) != includedScripts.end() )
{
// Already included
return false;
}
// Add the file to the set of included sections
includedScripts.insert(scriptFile);
return true;
}
int CScriptBuilder::LoadScriptSection(const char *filename)
{
// Open the script file
string scriptFile = filename;
#if _MSC_VER >= 1500 && !defined(__S3E__)
FILE *f = 0;
fopen_s(&f, scriptFile.c_str(), "rb");
#else
FILE *f = fopen(scriptFile.c_str(), "rb");
#endif
if( f == 0 )
{
// Write a message to the engine's message callback
string msg = "Failed to open script file '" + GetAbsolutePath(scriptFile) + "'";
engine->WriteMessage(filename, 0, 0, asMSGTYPE_ERROR, msg.c_str());
// TODO: Write the file where this one was included from
return -1;
}
// Determine size of the file
fseek(f, 0, SEEK_END);
int len = ftell(f);
fseek(f, 0, SEEK_SET);
// On Win32 it is possible to do the following instead
// int len = _filelength(_fileno(f));
// Read the entire file
string code;
size_t c = 0;
if( len > 0 )
{
code.resize(len);
c = fread(&code[0], len, 1, f);
}
fclose(f);
if( c == 0 && len > 0 )
{
// Write a message to the engine's message callback
string msg = "Failed to load script file '" + GetAbsolutePath(scriptFile) + "'";
engine->WriteMessage(filename, 0, 0, asMSGTYPE_ERROR, msg.c_str());
return -1;
}
// Process the script section even if it is zero length so that the name is registered
return ProcessScriptSection(code.c_str(), (unsigned int)(code.length()), filename, 0);
}
int CScriptBuilder::ProcessScriptSection(const char *script, unsigned int length, const char *sectionname, int lineOffset)
{
vector<string> includes;
// Perform a superficial parsing of the script first to store the metadata
if( length )
modifiedScript.assign(script, length);
else
modifiedScript = script;
// First perform the checks for #if directives to exclude code that shouldn't be compiled
unsigned int pos = 0;
int nested = 0;
while( pos < modifiedScript.size() )
{
asUINT len = 0;
asETokenClass t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_UNKNOWN && modifiedScript[pos] == '#' && (pos + 1 < modifiedScript.size()) )
{
int start = pos++;
// Is this an #if directive?
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
string token;
token.assign(&modifiedScript[pos], len);
pos += len;
if( token == "if" )
{
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_WHITESPACE )
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
}
if( t == asTC_IDENTIFIER )
{
string word;
word.assign(&modifiedScript[pos], len);
// Overwrite the #if directive with space characters to avoid compiler error
pos += len;
OverwriteCode(start, pos-start);
// Has this identifier been defined by the application or not?
if( definedWords.find(word) == definedWords.end() )
{
// Exclude all the code until and including the #endif
pos = ExcludeCode(pos);
}
else
{
nested++;
}
}
}
else if( token == "endif" )
{
// Only remove the #endif if there was a matching #if
if( nested > 0 )
{
OverwriteCode(start, pos-start);
nested--;
}
}
}
else
pos += len;
}
#if AS_PROCESS_METADATA == 1
// Preallocate memory
string name, declaration;
vector<string> metadata;
declaration.reserve(100);
#endif
// Then check for meta data and #include directives
pos = 0;
while( pos < modifiedScript.size() )
{
asUINT len = 0;
asETokenClass t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_COMMENT || t == asTC_WHITESPACE )
{
pos += len;
continue;
}
#if AS_PROCESS_METADATA == 1
// Check if class
if( currentClass == "" && modifiedScript.substr(pos,len) == "class" )
{
// Get the identifier after "class"
do
{
pos += len;
if( pos >= modifiedScript.size() )
{
t = asTC_UNKNOWN;
break;
}
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
} while(t == asTC_COMMENT || t == asTC_WHITESPACE);
if( t == asTC_IDENTIFIER )
{
currentClass = modifiedScript.substr(pos,len);
// Search until first { or ; is encountered
while( pos < modifiedScript.length() )
{
engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
// If start of class section encountered stop
if( modifiedScript[pos] == '{' )
{
pos += len;
break;
}
else if (modifiedScript[pos] == ';')
{
// The class declaration has ended and there are no children
currentClass = "";
pos += len;
break;
}
// Check next symbol
pos += len;
}
}
continue;
}
// Check if end of class
if( currentClass != "" && modifiedScript[pos] == '}' )
{
currentClass = "";
pos += len;
continue;
}
// Check if namespace
if( modifiedScript.substr(pos,len) == "namespace" )
{
// Get the identifier after "namespace"
do
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
} while(t == asTC_COMMENT || t == asTC_WHITESPACE);
if( currentNamespace != "" )
currentNamespace += "::";
currentNamespace += modifiedScript.substr(pos,len);
// Search until first { is encountered
while( pos < modifiedScript.length() )
{
engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
// If start of namespace section encountered stop
if( modifiedScript[pos] == '{' )
{
pos += len;
break;
}
// Check next symbol
pos += len;
}
continue;
}
// Check if end of namespace
if( currentNamespace != "" && modifiedScript[pos] == '}' )
{
size_t found = currentNamespace.rfind( "::" );
if( found != string::npos )
{
currentNamespace.erase( found );
}
else
{
currentNamespace = "";
}
pos += len;
continue;
}
// Is this the start of metadata?
if( modifiedScript[pos] == '[' )
{
// Get the metadata string
pos = ExtractMetadata(pos, metadata);
// Determine what this metadata is for
int type;
ExtractDeclaration(pos, name, declaration, type);
// Store away the declaration in a map for lookup after the build has completed
if( type > 0 )
{
SMetadataDecl decl(metadata, name, declaration, type, currentClass, currentNamespace);
foundDeclarations.push_back(decl);
}
}
else
#endif
// Is this a preprocessor directive?
if( modifiedScript[pos] == '#' && (pos + 1 < modifiedScript.size()) )
{
int start = pos++;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_IDENTIFIER )
{
string token;
token.assign(&modifiedScript[pos], len);
if( token == "include" )
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_WHITESPACE )
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
}
if( t == asTC_VALUE && len > 2 && (modifiedScript[pos] == '"' || modifiedScript[pos] == '\'') )
{
// Get the include file
string includefile;
includefile.assign(&modifiedScript[pos+1], len-2);
pos += len;
// Store it for later processing
includes.push_back(includefile);
// Overwrite the include directive with space characters to avoid compiler error
OverwriteCode(start, pos-start);
}
}
else if (token == "pragma")
{
// Read until the end of the line
pos += len;
for (; pos < modifiedScript.size() && modifiedScript[pos] != '\n'; pos++);
// Call the pragma callback
string pragmaText(&modifiedScript[start + 7], pos - start - 7);
int r = pragmaCallback ? pragmaCallback(pragmaText, *this, pragmaParam) : -1;
if (r < 0)
{
// TODO: Report the correct line number
engine->WriteMessage(sectionname, 0, 0, asMSGTYPE_ERROR, "Invalid #pragma directive");
return r;
}
// Overwrite the pragma directive with space characters to avoid compiler error
OverwriteCode(start, pos - start);
}
}
}
// Don't search for metadata/includes within statement blocks or between tokens in statements
else
{
pos = SkipStatement(pos);
}
}
// Build the actual script
engine->SetEngineProperty(asEP_COPY_SCRIPT_SECTIONS, true);
module->AddScriptSection(sectionname, modifiedScript.c_str(), modifiedScript.size(), lineOffset);
if( includes.size() > 0 )
{
// If the callback has been set, then call it for each included file
if( includeCallback )
{
for( int n = 0; n < (int)includes.size(); n++ )
{
int r = includeCallback(includes[n].c_str(), sectionname, this, includeParam);
if( r < 0 )
return r;
}
}
else
{
// By default we try to load the included file from the relative directory of the current file
// Determine the path of the current script so that we can resolve relative paths for includes
string path = sectionname;
size_t posOfSlash = path.find_last_of("/\\");
if( posOfSlash != string::npos )
path.resize(posOfSlash+1);
else
path = "";
// Load the included scripts
for( int n = 0; n < (int)includes.size(); n++ )
{
// If the include is a relative path, then prepend the path of the originating script
if( includes[n].find_first_of("/\\") != 0 &&
includes[n].find_first_of(":") == string::npos )
{
includes[n] = path + includes[n];
}
// Include the script section
int r = AddSectionFromFile(includes[n].c_str());
if( r < 0 )
return r;
}
}
}
return 0;
}
int CScriptBuilder::Build()
{
int r = module->Build();
if( r < 0 )
return r;
#if AS_PROCESS_METADATA == 1
// After the script has been built, the metadata strings should be
// stored for later lookup by function id, type id, and variable index
for( int n = 0; n < (int)foundDeclarations.size(); n++ )
{
SMetadataDecl *decl = &foundDeclarations[n];
module->SetDefaultNamespace(decl->nameSpace.c_str());
if( decl->type == MDT_TYPE )
{
// Find the type id
int typeId = module->GetTypeIdByDecl(decl->declaration.c_str());
assert( typeId >= 0 );
if( typeId >= 0 )
typeMetadataMap.insert(map<int, vector<string> >::value_type(typeId, decl->metadata));
}
else if( decl->type == MDT_FUNC )
{
if( decl->parentClass == "" )
{
// Find the function id
asIScriptFunction *func = module->GetFunctionByDecl(decl->declaration.c_str());
assert( func );
if( func )
funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
else
{
// Find the method id
int typeId = module->GetTypeIdByDecl(decl->parentClass.c_str());
assert( typeId > 0 );
map<int, SClassMetadata>::iterator it = classMetadataMap.find(typeId);
if( it == classMetadataMap.end() )
{
classMetadataMap.insert(map<int, SClassMetadata>::value_type(typeId, SClassMetadata(decl->parentClass)));
it = classMetadataMap.find(typeId);
}
asITypeInfo *type = engine->GetTypeInfoById(typeId);
asIScriptFunction *func = type->GetMethodByDecl(decl->declaration.c_str());
assert( func );
if( func )
it->second.funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
}
else if( decl->type == MDT_VIRTPROP )
{
if( decl->parentClass == "" )
{
// Find the global virtual property accessors
asIScriptFunction *func = module->GetFunctionByName(("get_" + decl->declaration).c_str());
if( func )
funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
func = module->GetFunctionByName(("set_" + decl->declaration).c_str());
if( func )
funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
else
{
// Find the method virtual property accessors
int typeId = module->GetTypeIdByDecl(decl->parentClass.c_str());
assert( typeId > 0 );
map<int, SClassMetadata>::iterator it = classMetadataMap.find(typeId);
if( it == classMetadataMap.end() )
{
classMetadataMap.insert(map<int, SClassMetadata>::value_type(typeId, SClassMetadata(decl->parentClass)));
it = classMetadataMap.find(typeId);
}
asITypeInfo *type = engine->GetTypeInfoById(typeId);
asIScriptFunction *func = type->GetMethodByName(("get_" + decl->declaration).c_str());
if( func )
it->second.funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
func = type->GetMethodByName(("set_" + decl->declaration).c_str());
if( func )
it->second.funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
}
else if( decl->type == MDT_VAR )
{
if( decl->parentClass == "" )
{
// Find the global variable index
int varIdx = module->GetGlobalVarIndexByName(decl->declaration.c_str());
assert( varIdx >= 0 );
if( varIdx >= 0 )
varMetadataMap.insert(map<int, vector<string> >::value_type(varIdx, decl->metadata));
}
else
{
int typeId = module->GetTypeIdByDecl(decl->parentClass.c_str());
assert( typeId > 0 );
// Add the classes if needed
map<int, SClassMetadata>::iterator it = classMetadataMap.find(typeId);
if( it == classMetadataMap.end() )
{
classMetadataMap.insert(map<int, SClassMetadata>::value_type(typeId, SClassMetadata(decl->parentClass)));
it = classMetadataMap.find(typeId);
}
// Add the variable to class
asITypeInfo *objectType = engine->GetTypeInfoById(typeId);
int idx = -1;
// Search through all properties to get proper declaration
for( asUINT i = 0; i < (asUINT)objectType->GetPropertyCount(); ++i )
{
const char *name;
objectType->GetProperty(i, &name);
if( decl->declaration == name )
{
idx = i;
break;
}
}
// If found, add it
assert( idx >= 0 );
if( idx >= 0 ) it->second.varMetadataMap.insert(map<int, vector<string> >::value_type(idx, decl->metadata));
}
}
else if (decl->type == MDT_FUNC_OR_VAR)
{
if (decl->parentClass == "")
{
// Find the global variable index
int varIdx = module->GetGlobalVarIndexByName(decl->name.c_str());
if (varIdx >= 0)
varMetadataMap.insert(map<int, vector<string> >::value_type(varIdx, decl->metadata));
else
{
asIScriptFunction *func = module->GetFunctionByDecl(decl->declaration.c_str());
assert(func);
if (func)
funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
}
else
{
int typeId = module->GetTypeIdByDecl(decl->parentClass.c_str());
assert(typeId > 0);
// Add the classes if needed
map<int, SClassMetadata>::iterator it = classMetadataMap.find(typeId);
if (it == classMetadataMap.end())
{
classMetadataMap.insert(map<int, SClassMetadata>::value_type(typeId, SClassMetadata(decl->parentClass)));
it = classMetadataMap.find(typeId);
}
// Add the variable to class
asITypeInfo *objectType = engine->GetTypeInfoById(typeId);
int idx = -1;
// Search through all properties to get proper declaration
for (asUINT i = 0; i < (asUINT)objectType->GetPropertyCount(); ++i)
{
const char *name;
objectType->GetProperty(i, &name);
if (decl->name == name)
{
idx = i;
break;
}
}
// If found, add it
if (idx >= 0)
it->second.varMetadataMap.insert(map<int, vector<string> >::value_type(idx, decl->metadata));
else
{
// Look for the matching method instead
asITypeInfo *type = engine->GetTypeInfoById(typeId);
asIScriptFunction *func = type->GetMethodByDecl(decl->declaration.c_str());
assert(func);
if (func)
it->second.funcMetadataMap.insert(map<int, vector<string> >::value_type(func->GetId(), decl->metadata));
}
}
}
}
module->SetDefaultNamespace("");
#endif
return 0;
}
int CScriptBuilder::SkipStatement(int pos)
{
asUINT len = 0;
// Skip until ; or { whichever comes first
while( pos < (int)modifiedScript.length() && modifiedScript[pos] != ';' && modifiedScript[pos] != '{' )
{
engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
pos += len;
}
// Skip entire statement block
if( pos < (int)modifiedScript.length() && modifiedScript[pos] == '{' )
{
pos += 1;
// Find the end of the statement block
int level = 1;
while( level > 0 && pos < (int)modifiedScript.size() )
{
asETokenClass t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( t == asTC_KEYWORD )
{
if( modifiedScript[pos] == '{' )
level++;
else if( modifiedScript[pos] == '}' )
level--;
}
pos += len;
}
}
else
pos += 1;
return pos;
}
// Overwrite all code with blanks until the matching #endif
int CScriptBuilder::ExcludeCode(int pos)
{
asUINT len = 0;
int nested = 0;
while( pos < (int)modifiedScript.size() )
{
engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if( modifiedScript[pos] == '#' )
{
modifiedScript[pos] = ' ';
pos++;
// Is it an #if or #endif directive?
engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
string token;
token.assign(&modifiedScript[pos], len);
OverwriteCode(pos, len);
if( token == "if" )
{
nested++;
}
else if( token == "endif" )
{
if( nested-- == 0 )
{
pos += len;
break;
}
}
}
else if( modifiedScript[pos] != '\n' )
{
OverwriteCode(pos, len);
}
pos += len;
}
return pos;
}
// Overwrite all characters except line breaks with blanks
void CScriptBuilder::OverwriteCode(int start, int len)
{
char *code = &modifiedScript[start];
for( int n = 0; n < len; n++ )
{
if( *code != '\n' )
*code = ' ';
code++;
}
}
#if AS_PROCESS_METADATA == 1
int CScriptBuilder::ExtractMetadata(int pos, vector<string> &metadata)
{
metadata.clear();
// Extract all metadata. They can be separated by whitespace and comments
for (;;)
{
string metadataString = "";
// Overwrite the metadata with space characters to allow compilation
modifiedScript[pos] = ' ';
// Skip opening brackets
pos += 1;
int level = 1;
asUINT len = 0;
while (level > 0 && pos < (int)modifiedScript.size())
{
asETokenClass t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
if (t == asTC_KEYWORD)
{
if (modifiedScript[pos] == '[')
level++;
else if (modifiedScript[pos] == ']')
level--;
}
// Copy the metadata to our buffer
if (level > 0)
metadataString.append(&modifiedScript[pos], len);
// Overwrite the metadata with space characters to allow compilation
if (t != asTC_WHITESPACE)
OverwriteCode(pos, len);
pos += len;
}
metadata.push_back(metadataString);
// Check for more metadata. Possibly separated by comments
asETokenClass t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
while (t == asTC_COMMENT || t == asTC_WHITESPACE)
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
}
if (modifiedScript[pos] != '[')
break;
}
return pos;
}
int CScriptBuilder::ExtractDeclaration(int pos, string &name, string &declaration, int &type)
{
declaration = "";
type = 0;
int start = pos;
std::string token;
asUINT len = 0;
asETokenClass t = asTC_WHITESPACE;
// Skip white spaces, comments, and leading decorators
do
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
token.assign(&modifiedScript[pos], len);
} while ( t == asTC_WHITESPACE || t == asTC_COMMENT ||
token == "private" || token == "protected" ||
token == "shared" || token == "external" ||
token == "final" || token == "abstract" );
// We're expecting, either a class, interface, function, or variable declaration
if( t == asTC_KEYWORD || t == asTC_IDENTIFIER )
{
token.assign(&modifiedScript[pos], len);
if( token == "interface" || token == "class" || token == "enum" )
{
// Skip white spaces and comments
do
{
pos += len;
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
} while ( t == asTC_WHITESPACE || t == asTC_COMMENT );
if( t == asTC_IDENTIFIER )
{
type = MDT_TYPE;
declaration.assign(&modifiedScript[pos], len);
pos += len;
return pos;
}
}
else
{
// For function declarations, store everything up to the start of the
// statement block, except for succeeding decorators (final, override, etc)
// For variable declaration store just the name as there can only be one
// We'll only know if the declaration is a variable or function declaration
// when we see the statement block, or absense of a statement block.
bool hasParenthesis = false;
int nestedParenthesis = 0;
declaration.append(&modifiedScript[pos], len);
pos += len;
for(; pos < (int)modifiedScript.size();)
{
t = engine->ParseToken(&modifiedScript[pos], modifiedScript.size() - pos, &len);
token.assign(&modifiedScript[pos], len);
if (t == asTC_KEYWORD)
{
if (token == "{" && nestedParenthesis == 0)
{
if (hasParenthesis)
{
// We've found the end of a function signature
type = MDT_FUNC;
}
else
{
// We've found a virtual property. Just keep the name
declaration = name;
type = MDT_VIRTPROP;
}
return pos;
}
if ((token == "=" && !hasParenthesis) || token == ";")
{
if (hasParenthesis)
{
// The declaration is ambigous. It can be a variable with initialization, or a function prototype
type = MDT_FUNC_OR_VAR;
}
else
{
// Substitute the declaration with just the name
declaration = name;
type = MDT_VAR;
}
return pos;
}
else if (token == "(")
{
nestedParenthesis++;
// This is the first parenthesis we encounter. If the parenthesis isn't followed
// by a statement block, then this is a variable declaration, in which case we
// should only store the type and name of the variable, not the initialization parameters.
hasParenthesis = true;
}
else if (token == ")")
{
nestedParenthesis--;
}
}
else if( t == asTC_IDENTIFIER )
{
name = token;
}
// Skip trailing decorators
if( !hasParenthesis || nestedParenthesis > 0 || t != asTC_IDENTIFIER || (token != "final" && token != "override") )
declaration += token;
pos += len;
}
}
}
return start;
}
vector<string> CScriptBuilder::GetMetadataForType(int typeId)
{
map<int,vector<string> >::iterator it = typeMetadataMap.find(typeId);
if( it != typeMetadataMap.end() )
return it->second;
return vector<string>();
}
vector<string> CScriptBuilder::GetMetadataForFunc(asIScriptFunction *func)
{
if( func )
{
map<int,vector<string> >::iterator it = funcMetadataMap.find(func->GetId());
if( it != funcMetadataMap.end() )
return it->second;
}
return vector<string>();
}
vector<string> CScriptBuilder::GetMetadataForVar(int varIdx)
{
map<int,vector<string> >::iterator it = varMetadataMap.find(varIdx);
if( it != varMetadataMap.end() )
return it->second;
return vector<string>();
}
vector<string> CScriptBuilder::GetMetadataForTypeProperty(int typeId, int varIdx)
{
map<int, SClassMetadata>::iterator typeIt = classMetadataMap.find(typeId);
if(typeIt == classMetadataMap.end()) return vector<string>();
map<int, vector<string> >::iterator propIt = typeIt->second.varMetadataMap.find(varIdx);
if(propIt == typeIt->second.varMetadataMap.end()) return vector<string>();
return propIt->second;
}
vector<string> CScriptBuilder::GetMetadataForTypeMethod(int typeId, asIScriptFunction *method)
{
if( method )
{
map<int, SClassMetadata>::iterator typeIt = classMetadataMap.find(typeId);
if (typeIt == classMetadataMap.end()) return vector<string>();
map<int, vector<string> >::iterator methodIt = typeIt->second.funcMetadataMap.find(method->GetId());
if(methodIt == typeIt->second.funcMetadataMap.end()) return vector<string>();
return methodIt->second;
}
return vector<string>();
}
#endif
string GetAbsolutePath(const string &file)
{
string str = file;
// If this is a relative path, complement it with the current path
if( !((str.length() > 0 && (str[0] == '/' || str[0] == '\\')) ||
str.find(":") != string::npos) )
{
str = GetCurrentDir() + "/" + str;
}
// Replace backslashes for forward slashes
size_t pos = 0;
while( (pos = str.find("\\", pos)) != string::npos )
str[pos] = '/';
// Replace /./ with /
pos = 0;
while( (pos = str.find("/./", pos)) != string::npos )
str.erase(pos+1, 2);
// For each /../ remove the parent dir and the /../
pos = 0;
while( (pos = str.find("/../")) != string::npos )
{
size_t pos2 = str.rfind("/", pos-1);
if( pos2 != string::npos )
str.erase(pos2, pos+3-pos2);
else
{
// The path is invalid
break;
}
}
return str;
}
string GetCurrentDir()
{
char buffer[1024];
#if defined(_MSC_VER) || defined(_WIN32)
#ifdef _WIN32_WCE
static TCHAR apppath[MAX_PATH] = TEXT("");
if (!apppath[0])
{
GetModuleFileName(NULL, apppath, MAX_PATH);
int appLen = _tcslen(apppath);
// Look for the last backslash in the path, which would be the end
// of the path itself and the start of the filename. We only want
// the path part of the exe's full-path filename
// Safety is that we make sure not to walk off the front of the
// array (in case the path is nothing more than a filename)
while (appLen > 1)
{
if (apppath[appLen-1] == TEXT('\\'))
break;
appLen--;
}
// Terminate the string after the trailing backslash
apppath[appLen] = TEXT('\0');
}
#ifdef _UNICODE
wcstombs(buffer, apppath, min(1024, wcslen(apppath)*sizeof(wchar_t)));
#else
memcpy(buffer, apppath, min(1024, strlen(apppath)));
#endif
return buffer;
#elif defined(__S3E__)
// Marmalade uses its own portable C library
return getcwd(buffer, (int)1024);
#elif _XBOX_VER >= 200
// XBox 360 doesn't support the getcwd function, just use the root folder
return "game:/";
#elif defined(_M_ARM)
// TODO: How to determine current working dir on Windows Phone?
return "";
#else
return _getcwd(buffer, (int)1024);
#endif // _MSC_VER
#elif defined(__APPLE__) || defined(__linux__)
return getcwd(buffer, 1024);
#else
return "";
#endif
}
END_AS_NAMESPACE