libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-22 09:49:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

WINTERMUTE: Rename FuncName/VarName->funcName/varName in ScEngine

Browse Source
This commit is contained in:
Einar Johan Trøan Sømåen 2012-07-08 23:51:47 +02:00
parent f29bc84bdb
commit cb06b9feec
8 changed files with 189 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
engines/wintermute/Ad/AdGame.cpp
View File

@ -1707,7 +1707,7 @@ HRESULT CAdGame::displayContent(bool update, bool displayAll) {
} else {
// process scripts
if (update) _scEngine->Tick();
if (update) _scEngine->tick();
POINT p;
getMousePos(&p);

2
engines/wintermute/Ad/AdObject.cpp
View File

@ -946,7 +946,7 @@ HRESULT CAdObject::reset() {
_state = _nextState = STATE_READY;
Game->_scEngine->ResetObject(this);
Game->_scEngine->resetObject(this);
return S_OK;
}

16
engines/wintermute/Base/BGame.cpp
View File

@ -1990,7 +1990,7 @@ HRESULT CBGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ClearScriptCache") == 0) {
stack->correctParams(0);
stack->pushBool(SUCCEEDED(_scEngine->EmptyScriptCache()));
stack->pushBool(SUCCEEDED(_scEngine->emptyScriptCache()));
return S_OK;
}
@ -2130,7 +2130,7 @@ HRESULT CBGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "EnableScriptProfiling") == 0) {
stack->correctParams(0);
_scEngine->EnableProfiling();
_scEngine->enableProfiling();
stack->pushNULL();
return S_OK;
@ -2141,7 +2141,7 @@ HRESULT CBGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DisableScriptProfiling") == 0) {
stack->correctParams(0);
_scEngine->DisableProfiling();
_scEngine->disableProfiling();
stack->pushNULL();
return S_OK;
@ -3358,7 +3358,7 @@ HRESULT CBGame::initAfterLoad() {
CSysClassRegistry::getInstance()->enumInstances(afterLoadFont, "CBFontTT", NULL);
CSysClassRegistry::getInstance()->enumInstances(afterLoadScript, "CScScript", NULL);
_scEngine->RefreshScriptBreakpoints();
_scEngine->refreshScriptBreakpoints();
if (_store) _store->afterLoad();
return S_OK;
@ -3745,7 +3745,7 @@ HRESULT CBGame::focusWindow(CUIWindow *Window) {
//////////////////////////////////////////////////////////////////////////
HRESULT CBGame::freeze(bool includingMusic) {
if (_freezeLevel == 0) {
_scEngine->PauseAll();
_scEngine->pauseAll();
_soundMgr->pauseAll(includingMusic);
_origState = _state;
_origInteractive = _interactive;
@ -3766,7 +3766,7 @@ HRESULT CBGame::unfreeze() {
if (_freezeLevel == 0) {
_state = _origState;
_interactive = _origInteractive;
_scEngine->ResumeAll();
_scEngine->resumeAll();
_soundMgr->resumeAll();
}
@ -4171,7 +4171,7 @@ HRESULT CBGame::updateMusicCrossfade() {
//////////////////////////////////////////////////////////////////////////
HRESULT CBGame::resetContent() {
_scEngine->ClearGlobals();
_scEngine->clearGlobals();
//_timer = 0;
//_liveTimer = 0;
@ -4432,7 +4432,7 @@ HRESULT CBGame::displayDebugInfo() {
_renderer->displayDebugInfo();
int scrTotal, scrRunning, scrWaiting, scrPersistent;
scrTotal = _scEngine->GetNumScripts(&scrRunning, &scrWaiting, &scrPersistent);
scrTotal = _scEngine->getNumScripts(&scrRunning, &scrWaiting, &scrPersistent);
sprintf(str, "Running scripts: %d (r:%d w:%d p:%d)", scrTotal, scrRunning, scrWaiting, scrPersistent);
_systemFont->drawText((byte *)str, 0, 70, _renderer->_width, TAL_RIGHT);

4
engines/wintermute/Base/BScriptHolder.cpp
View File

@ -94,7 +94,7 @@ HRESULT CBScriptHolder::applyEvent(const char *eventName, bool unbreakable) {
}
}
}
if (numHandlers > 0 && unbreakable) Game->_scEngine->TickUnbreakable();
if (numHandlers > 0 && unbreakable) Game->_scEngine->tickUnbreakable();
return ret;
}
@ -286,7 +286,7 @@ HRESULT CBScriptHolder::addScript(const char *filename) {
}
}
CScScript *scr = Game->_scEngine->RunScript(filename, this);
CScScript *scr = Game->_scEngine->runScript(filename, this);
if (!scr) {
if (Game->_editorForceScripts) {
// editor hack

266
engines/wintermute/Base/scriptables/ScEngine.cpp
View File

@ -141,9 +141,9 @@ CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) {
//////////////////////////////////////////////////////////////////////////
CScEngine::~CScEngine() {
Game->LOG(0, "Shutting down scripting engine");
SaveBreakpoints();
saveBreakpoints();
DisableProfiling();
disableProfiling();
#ifdef __WIN32__
if (_compilerAvailable && _compilerDLL) ::FreeLibrary(_compilerDLL);
#endif
@ -171,7 +171,7 @@ HRESULT CScEngine::cleanup() {
delete _globals;
_globals = NULL;
EmptyScriptCache();
emptyScriptCache();
_currentScript = NULL; // ref only
@ -189,55 +189,55 @@ HRESULT CScEngine::cleanup() {
//////////////////////////////////////////////////////////////////////////
byte *WINAPI CScEngine::loadFile(void *data, char *filename, uint32 *size) {
byte *CScEngine::loadFile(void *data, char *filename, uint32 *size) {
CBGame *Game = (CBGame *)data;
return Game->_fileManager->readWholeFile(filename, size);
}
//////////////////////////////////////////////////////////////////////////
void WINAPI CScEngine::CloseFile(void *Data, byte *Buffer) {
delete [] Buffer;
void CScEngine::closeFile(void *data, byte *buffer) {
delete [] buffer;
}
//////////////////////////////////////////////////////////////////////////
void WINAPI CScEngine::AddError(void *Data, int Line, char *Text) {
CBGame *Game = (CBGame *)Data;
void CScEngine::addError(void *data, int line, char *text) {
CBGame *Game = (CBGame *)data;
if (Game) {
if (Game->_scEngine && Game->_scEngine->_fileToCompile)
Game->LOG(0, "Compiling script '%s'...", Game->_scEngine->_fileToCompile);
Game->LOG(0, " Error@line %d: %s", Line, Text);
Game->LOG(0, " Error@line %d: %s", line, text);
// redirect to an engine's own callback
if (Game->_scEngine && Game->_scEngine->_compileErrorCallback) {
Game->_scEngine->_compileErrorCallback(Line, Text, Game->_scEngine->_compileErrorCallbackData);
Game->_scEngine->_compileErrorCallback(line, text, Game->_scEngine->_compileErrorCallbackData);
}
}
}
//////////////////////////////////////////////////////////////////////////
void WINAPI CScEngine::ParseElement(void *Data, int Line, int Type, void *ElementData) {
CBGame *Game = (CBGame *)Data;
void WINAPI CScEngine::parseElement(void *data, int line, int type, void *elementData) {
CBGame *Game = (CBGame *)data;
if (Game) {
// redirect to an engine's own callback
if (Game->_scEngine && Game->_scEngine->_parseElementCallback) {
Game->_scEngine->_parseElementCallback(Line, Type, ElementData, Game->_scEngine->_compileErrorCallbackData);
Game->_scEngine->_parseElementCallback(line, type, elementData, Game->_scEngine->_compileErrorCallbackData);
}
}
}
//////////////////////////////////////////////////////////////////////////
CScScript *CScEngine::RunScript(const char *filename, CBScriptHolder *owner) {
CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
byte *compBuffer;
uint32 compSize;
// get script from cache
compBuffer = GetCompiledScript(filename, &compSize);
compBuffer = getCompiledScript(filename, &compSize);
if (!compBuffer) return NULL;
// add new script
@ -265,52 +265,50 @@ CScScript *CScEngine::RunScript(const char *filename, CBScriptHolder *owner) {
//////////////////////////////////////////////////////////////////////////
byte *CScEngine::GetCompiledScript(const char *filename, uint32 *OutSize, bool IgnoreCache) {
int i;
byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
// is script in cache?
if (!IgnoreCache) {
for (i = 0; i < MAX_CACHED_SCRIPTS; i++) {
if (!ignoreCache) {
for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
if (_cachedScripts[i] && scumm_stricmp(_cachedScripts[i]->_filename.c_str(), filename) == 0) {
_cachedScripts[i]->_timestamp = CBPlatform::GetTime();
*OutSize = _cachedScripts[i]->_size;
*outSize = _cachedScripts[i]->_size;
return _cachedScripts[i]->_buffer;
}
}
}
// nope, load it
byte *CompBuffer;
uint32 CompSize;
bool CompiledNow = false;
byte *compBuffer;
uint32 compSize;
bool compiledNow = false;
uint32 Size;
uint32 size;
byte *Buffer = Game->_fileManager->readWholeFile(filename, &Size);
if (!Buffer) {
byte *buffer = Game->_fileManager->readWholeFile(filename, &size);
if (!buffer) {
Game->LOG(0, "CScEngine::GetCompiledScript - error opening script '%s'", filename);
return NULL;
}
// needs to be compiled?
if (FROM_LE_32(*(uint32 *)Buffer) == SCRIPT_MAGIC) {
CompBuffer = Buffer;
CompSize = Size;
if (FROM_LE_32(*(uint32 *)buffer) == SCRIPT_MAGIC) {
compBuffer = buffer;
compSize = size;
} else {
if (!_compilerAvailable) {
Game->LOG(0, "CScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
delete [] Buffer;
delete [] buffer;
return NULL;
}
CompiledNow = true;
compiledNow = true;
// publish external methods to the compiler
CALLBACKS c;
c.Dll_AddError = AddError;
c.Dll_CloseFile = CloseFile;
c.Dll_AddError = addError;
c.Dll_CloseFile = closeFile;
c.Dll_LoadFile = loadFile;
c.Dll_ParseElement = ParseElement;
c.Dll_ParseElement = parseElement;
ExtSetCallbacks(&c, Game);
// publish native interfaces
@ -320,12 +318,12 @@ byte *CScEngine::GetCompiledScript(const char *filename, uint32 *OutSize, bool I
char *tempFileName = new char[strlen(filename) + 1];
memcpy(tempFileName, filename, strlen(filename) + 1);
SetFileToCompile(filename);
CompBuffer = ExtCompileFile(tempFileName, &CompSize);
setFileToCompile(filename);
compBuffer = ExtCompileFile(tempFileName, &compSize);
delete[] tempFileName;
if (!CompBuffer) {
if (!compBuffer) {
Game->quickMessage("Script compiler error. View log for details.");
delete [] Buffer;
delete [] buffer;
return NULL;
}
}
@ -333,11 +331,11 @@ byte *CScEngine::GetCompiledScript(const char *filename, uint32 *OutSize, bool I
byte *ret = NULL;
// add script to cache
CScCachedScript *CachedScript = new CScCachedScript(filename, CompBuffer, CompSize);
if (CachedScript) {
CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
if (cachedScript) {
int index = 0;
uint32 MinTime = CBPlatform::GetTime();
for (i = 0; i < MAX_CACHED_SCRIPTS; i++) {
for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
if (_cachedScripts[i] == NULL) {
index = i;
break;
@ -348,16 +346,16 @@ byte *CScEngine::GetCompiledScript(const char *filename, uint32 *OutSize, bool I
}
if (_cachedScripts[index] != NULL) delete _cachedScripts[index];
_cachedScripts[index] = CachedScript;
_cachedScripts[index] = cachedScript;
ret = CachedScript->_buffer;
*OutSize = CachedScript->_size;
ret = cachedScript->_buffer;
*outSize = cachedScript->_size;
}
// cleanup
delete [] Buffer;
if (CompiledNow) ExtReleaseBuffer(CompBuffer);
delete [] buffer;
if (compiledNow) ExtReleaseBuffer(compBuffer);
return ret;
}
@ -365,14 +363,14 @@ byte *CScEngine::GetCompiledScript(const char *filename, uint32 *OutSize, bool I
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::Tick() {
int i;
HRESULT CScEngine::tick() {
if (_scripts.GetSize() == 0) return S_OK;
// resolve waiting scripts
for (i = 0; i < _scripts.GetSize(); i++) {
for (int i = 0; i < _scripts.GetSize(); i++) {
switch (_scripts[i]->_state) {
case SCRIPT_WAITING: {
@ -405,7 +403,7 @@ HRESULT CScEngine::Tick() {
}
case SCRIPT_WAITING_SCRIPT: {
if (!IsValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
if (!isValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
// fake return value
_scripts[i]->_stack->pushNULL();
_scripts[i]->_waitScript = NULL;
@ -429,7 +427,7 @@ HRESULT CScEngine::Tick() {
// execute scripts
for (i = 0; i < _scripts.GetSize(); i++) {
for (int i = 0; i < _scripts.GetSize(); i++) {
// skip paused scripts
if (_scripts[i]->_state == SCRIPT_PAUSED) continue;
@ -441,7 +439,7 @@ HRESULT CScEngine::Tick() {
_currentScript = _scripts[i];
_scripts[i]->ExecuteInstruction();
}
if (_isProfiling && _scripts[i]->_filename) AddScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
if (_isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
}
// normal script
@ -454,19 +452,19 @@ HRESULT CScEngine::Tick() {
_currentScript = _scripts[i];
_scripts[i]->ExecuteInstruction();
}
if (isProfiling && _scripts[i]->_filename) AddScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
if (isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
}
_currentScript = NULL;
}
RemoveFinishedScripts();
removeFinishedScripts();
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::TickUnbreakable() {
HRESULT CScEngine::tickUnbreakable() {
// execute unbreakable scripts
for (int i = 0; i < _scripts.GetSize(); i++) {
if (!_scripts[i]->_unbreakable) continue;
@ -478,14 +476,14 @@ HRESULT CScEngine::TickUnbreakable() {
_scripts[i]->finish();
_currentScript = NULL;
}
RemoveFinishedScripts();
removeFinishedScripts();
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RemoveFinishedScripts() {
HRESULT CScEngine::removeFinishedScripts() {
// remove finished scripts
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
@ -501,8 +499,8 @@ HRESULT CScEngine::RemoveFinishedScripts() {
//////////////////////////////////////////////////////////////////////////
int CScEngine::GetNumScripts(int *Running, int *Waiting, int *Persistent) {
int running = 0, waiting = 0, persistent = 0, total = 0;
int CScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
int numRunning = 0, numWaiting = 0, numPersistent = 0, numTotal = 0;
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_state == SCRIPT_FINISHED) continue;
@ -510,30 +508,30 @@ int CScEngine::GetNumScripts(int *Running, int *Waiting, int *Persistent) {
case SCRIPT_RUNNING:
case SCRIPT_SLEEPING:
case SCRIPT_PAUSED:
running++;
numRunning++;
break;
case SCRIPT_WAITING:
waiting++;
numWaiting++;
break;
case SCRIPT_PERSISTENT:
persistent++;
numPersistent++;
break;
default:
warning("CScEngine::GetNumScripts - unhandled enum");
break;
}
total++;
numTotal++;
}
if (Running) *Running = running;
if (Waiting) *Waiting = waiting;
if (Persistent) *Persistent = persistent;
if (running) *running = numRunning;
if (waiting) *waiting = numWaiting;
if (persistent) *persistent = numPersistent;
return total;
return numTotal;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::EmptyScriptCache() {
HRESULT CScEngine::emptyScriptCache() {
for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
if (_cachedScripts[i]) {
delete _cachedScripts[i];
@ -545,11 +543,11 @@ HRESULT CScEngine::EmptyScriptCache() {
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResetObject(CBObject *Object) {
HRESULT CScEngine::resetObject(CBObject *Object) {
// terminate all scripts waiting for this object
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
if (!Game->_compatKillMethodThreads) ResetScript(_scripts[i]);
if (!Game->_compatKillMethodThreads) resetScript(_scripts[i]);
bool IsThread = _scripts[i]->_methodThread || _scripts[i]->_thread;
_scripts[i]->finish(!IsThread); // 1.9b1 - top-level script kills its threads as well
@ -559,7 +557,7 @@ HRESULT CScEngine::ResetObject(CBObject *Object) {
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResetScript(CScScript *script) {
HRESULT CScEngine::resetScript(CScScript *script) {
// terminate all scripts waiting for this script
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_state == SCRIPT_WAITING_SCRIPT && _scripts[i]->_waitScript == script) {
@ -596,7 +594,7 @@ void CScEngine::editorCleanup() {
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::PauseAll() {
HRESULT CScEngine::pauseAll() {
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i] != _currentScript) _scripts[i]->Pause();
}
@ -606,7 +604,7 @@ HRESULT CScEngine::PauseAll() {
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResumeAll() {
HRESULT CScEngine::resumeAll() {
for (int i = 0; i < _scripts.GetSize(); i++)
_scripts[i]->Resume();
@ -615,7 +613,7 @@ HRESULT CScEngine::ResumeAll() {
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::SetFileToCompile(const char *filename) {
HRESULT CScEngine::setFileToCompile(const char *filename) {
delete[] _fileToCompile;
_fileToCompile = new char[strlen(filename) + 1];
if (_fileToCompile) {
@ -626,20 +624,20 @@ HRESULT CScEngine::SetFileToCompile(const char *filename) {
//////////////////////////////////////////////////////////////////////////
void CScEngine::SetCompileErrorCallback(COMPILE_ERROR_CALLBACK Callback, void *Data) {
_compileErrorCallback = Callback;
_compileErrorCallbackData = Data;
void CScEngine::setCompileErrorCallback(COMPILE_ERROR_CALLBACK callback, void *data) {
_compileErrorCallback = callback;
_compileErrorCallbackData = data;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::SetParseElementCallback(PARSE_ELEMENT_CALLBACK Callback, void *Data) {
_parseElementCallback = Callback;
_parseElementCallbackData = Data;
void CScEngine::setParseElementCallback(PARSE_ELEMENT_CALLBACK callback, void *data) {
_parseElementCallback = callback;
_parseElementCallbackData = data;
}
//////////////////////////////////////////////////////////////////////////
bool CScEngine::IsValidScript(CScScript *script) {
bool CScEngine::isValidScript(CScScript *script) {
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i] == script) return true;
}
@ -647,73 +645,73 @@ bool CScEngine::IsValidScript(CScScript *script) {
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ClearGlobals(bool IncludingNatives) {
_globals->CleanProps(IncludingNatives);
HRESULT CScEngine::clearGlobals(bool includingNatives) {
_globals->CleanProps(includingNatives);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::DbgSendScripts(IWmeDebugClient *Client) {
HRESULT CScEngine::dbgSendScripts(IWmeDebugClient *client) {
// send global variables
_globals->DbgSendVariables(Client, WME_DBGVAR_GLOBAL, NULL, 0);
_globals->DbgSendVariables(client, WME_DBGVAR_GLOBAL, NULL, 0);
// process normal scripts first
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_thread || _scripts[i]->_methodThread) continue;
_scripts[i]->DbgSendScript(Client);
_scripts[i]->DbgSendScript(client);
}
// and threads later
for (int i = 0; i < _scripts.GetSize(); i++) {
if (_scripts[i]->_thread || _scripts[i]->_methodThread)
_scripts[i]->DbgSendScript(Client);
_scripts[i]->DbgSendScript(client);
}
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::addBreakpoint(const char *ScriptFilename, int Line) {
HRESULT CScEngine::addBreakpoint(const char *scriptFilename, int line) {
if (!Game->getDebugMgr()->_enabled) return S_OK;
CScBreakpoint *Bp = NULL;
CScBreakpoint *bp = NULL;
for (int i = 0; i < _breakpoints.GetSize(); i++) {
if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), ScriptFilename) == 0) {
Bp = _breakpoints[i];
if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), scriptFilename) == 0) {
bp = _breakpoints[i];
break;
}
}
if (Bp == NULL) {
Bp = new CScBreakpoint(ScriptFilename);
_breakpoints.Add(Bp);
if (bp == NULL) {
bp = new CScBreakpoint(scriptFilename);
_breakpoints.Add(bp);
}
for (int i = 0; i < Bp->_lines.GetSize(); i++) {
if (Bp->_lines[i] == Line) return S_OK;
for (int i = 0; i < bp->_lines.GetSize(); i++) {
if (bp->_lines[i] == line) return S_OK;
}
Bp->_lines.Add(Line);
bp->_lines.Add(line);
// refresh changes
RefreshScriptBreakpoints();
refreshScriptBreakpoints();
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::removeBreakpoint(const char *ScriptFilename, int Line) {
HRESULT CScEngine::removeBreakpoint(const char *scriptFilename, int line) {
if (!Game->getDebugMgr()->_enabled) return S_OK;
for (int i = 0; i < _breakpoints.GetSize(); i++) {
if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), ScriptFilename) == 0) {
if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), scriptFilename) == 0) {
for (int j = 0; j < _breakpoints[i]->_lines.GetSize(); j++) {
if (_breakpoints[i]->_lines[j] == Line) {
if (_breakpoints[i]->_lines[j] == line) {
_breakpoints[i]->_lines.RemoveAt(j);
if (_breakpoints[i]->_lines.GetSize() == 0) {
delete _breakpoints[i];
_breakpoints.RemoveAt(i);
}
// refresh changes
RefreshScriptBreakpoints();
refreshScriptBreakpoints();
return S_OK;
}
@ -725,17 +723,17 @@ HRESULT CScEngine::removeBreakpoint(const char *ScriptFilename, int Line) {
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RefreshScriptBreakpoints() {
HRESULT CScEngine::refreshScriptBreakpoints() {
if (!Game->getDebugMgr()->_enabled) return S_OK;
for (int i = 0; i < _scripts.GetSize(); i++) {
RefreshScriptBreakpoints(_scripts[i]);
refreshScriptBreakpoints(_scripts[i]);
}
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RefreshScriptBreakpoints(CScScript *script) {
HRESULT CScEngine::refreshScriptBreakpoints(CScScript *script) {
if (!Game->getDebugMgr()->_enabled) return S_OK;
if (!script || !script->_filename) return E_FAIL;
@ -752,48 +750,48 @@ HRESULT CScEngine::RefreshScriptBreakpoints(CScScript *script) {
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::SaveBreakpoints() {
HRESULT CScEngine::saveBreakpoints() {
if (!Game->getDebugMgr()->_enabled) return S_OK;
char Text[512];
char Key[100];
char text[512];
char key[100];
int Count = 0;
int count = 0;
for (int i = 0; i < _breakpoints.GetSize(); i++) {
for (int j = 0; j < _breakpoints[i]->_lines.GetSize(); j++) {
Count++;
sprintf(Key, "Breakpoint%d", Count);
sprintf(Text, "%s:%d", _breakpoints[i]->_filename.c_str(), _breakpoints[i]->_lines[j]);
count++;
sprintf(key, "Breakpoint%d", count);
sprintf(text, "%s:%d", _breakpoints[i]->_filename.c_str(), _breakpoints[i]->_lines[j]);
Game->_registry->writeString("Debug", Key, Text);
Game->_registry->writeString("Debug", key, text);
}
}
Game->_registry->writeInt("Debug", "NumBreakpoints", Count);
Game->_registry->writeInt("Debug", "NumBreakpoints", count);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::LoadBreakpoints() {
HRESULT CScEngine::loadBreakpoints() {
if (!Game->getDebugMgr()->_enabled) return S_OK;
char Key[100];
char key[100];
int Count = Game->_registry->readInt("Debug", "NumBreakpoints", 0);
for (int i = 1; i <= Count; i++) {
int count = Game->_registry->readInt("Debug", "NumBreakpoints", 0);
for (int i = 1; i <= count; i++) {
/* uint32 BufSize = 512; */
sprintf(Key, "Breakpoint%d", i);
AnsiString breakpoint = Game->_registry->readString("Debug", Key, "");
sprintf(key, "Breakpoint%d", i);
AnsiString breakpoint = Game->_registry->readString("Debug", key, "");
char *Path = CBUtils::strEntry(0, breakpoint.c_str(), ':');
char *Line = CBUtils::strEntry(1, breakpoint.c_str(), ':');
char *path = CBUtils::strEntry(0, breakpoint.c_str(), ':');
char *line = CBUtils::strEntry(1, breakpoint.c_str(), ':');
if (Path != NULL && Line != NULL) addBreakpoint(Path, atoi(Line));
delete[] Path;
delete[] Line;
Path = NULL;
Line = NULL;
if (path != NULL && line != NULL) addBreakpoint(path, atoi(line));
delete[] path;
delete[] line;
path = NULL;
line = NULL;
}
return S_OK;
@ -801,17 +799,17 @@ HRESULT CScEngine::LoadBreakpoints() {
//////////////////////////////////////////////////////////////////////////
void CScEngine::AddScriptTime(const char *filename, uint32 Time) {
void CScEngine::addScriptTime(const char *filename, uint32 time) {
if (!_isProfiling) return;
AnsiString fileName = filename;
StringUtil::toLowerCase(fileName);
_scriptTimes[fileName] += Time;
_scriptTimes[fileName] += time;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::EnableProfiling() {
void CScEngine::enableProfiling() {
if (_isProfiling) return;
// destroy old data, if any
@ -823,16 +821,16 @@ void CScEngine::EnableProfiling() {
//////////////////////////////////////////////////////////////////////////
void CScEngine::DisableProfiling() {
void CScEngine::disableProfiling() {
if (!_isProfiling) return;
DumpStats();
dumpStats();
_isProfiling = false;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::DumpStats() {
void CScEngine::dumpStats() {
error("DumpStats not ported to ScummVM yet");
/* uint32 totalTime = CBPlatform::GetTime() - _profilingStartTime;

82
engines/wintermute/Base/scriptables/ScEngine.h
View File

@ -38,15 +38,15 @@
namespace WinterMute {
typedef byte *(*DLL_COMPILE_BUFFER)(byte *Buffer, char *Source, uint32 BufferSize, uint32 *CompiledSize);
typedef byte *(*DLL_COMPILE_FILE)(char *Filename, uint32 *CompiledSize);
typedef void (*DLL_RELEASE_BUFFER)(unsigned char *Buffer);
typedef byte *(*DLL_COMPILE_BUFFER)(byte *buffer, char *source, uint32 bufferSize, uint32 *compiledSize);
typedef byte *(*DLL_COMPILE_FILE)(char *filename, uint32 *compiledSize);
typedef void (*DLL_RELEASE_BUFFER)(unsigned char *buffer);
typedef void (*DLL_SET_CALLBACKS)(CALLBACKS *callbacks, void *Data);
typedef int (*DLL_DEFINE_FUNCTION)(const char *name); /* Was non-const, changed to silence warnings */
typedef int (*DLL_DEFINE_VARIABLE)(const char *name); /* Was non-const, changed to silence warnings */
typedef void (*COMPILE_ERROR_CALLBACK)(int Line, char *Text , void *Data);
typedef void (*PARSE_ELEMENT_CALLBACK)(int Line, int Type, void *ElementData, void *Data);
typedef void (*COMPILE_ERROR_CALLBACK)(int line, char *text , void *data);
typedef void (*PARSE_ELEMENT_CALLBACK)(int line, int type, void *elementData, void *data);
#define MAX_CACHED_SCRIPTS 20
class CScScript;
@ -57,11 +57,11 @@ class CScEngine : public CBBase {
public:
class CScCachedScript {
public:
CScCachedScript(const char *filename, byte *Buffer, uint32 Size) {
CScCachedScript(const char *filename, byte *buffer, uint32 size) {
_timestamp = CBPlatform::GetTime();
_buffer = new byte[Size];
if (_buffer) memcpy(_buffer, Buffer, Size);
_size = Size;
_buffer = new byte[size];
if (_buffer) memcpy(_buffer, buffer, size);
_size = size;
_filename = filename;
};
@ -93,22 +93,22 @@ public:
public:
HRESULT DbgSendScripts(IWmeDebugClient *Client);
HRESULT dbgSendScripts(IWmeDebugClient *client);
CBArray<CScBreakpoint *, CScBreakpoint *> _breakpoints;
HRESULT addBreakpoint(const char *ScriptFilename, int Line);
HRESULT removeBreakpoint(const char *ScriptFilename, int Line);
HRESULT RefreshScriptBreakpoints();
HRESULT RefreshScriptBreakpoints(CScScript *script);
HRESULT SaveBreakpoints();
HRESULT LoadBreakpoints();
HRESULT addBreakpoint(const char *scriptFilename, int line);
HRESULT removeBreakpoint(const char *scriptFilename, int line);
HRESULT refreshScriptBreakpoints();
HRESULT refreshScriptBreakpoints(CScScript *script);
HRESULT saveBreakpoints();
HRESULT loadBreakpoints();
HRESULT ClearGlobals(bool IncludingNatives = false);
HRESULT TickUnbreakable();
HRESULT RemoveFinishedScripts();
bool IsValidScript(CScScript *script);
void SetCompileErrorCallback(COMPILE_ERROR_CALLBACK Callback, void *Data);
void SetParseElementCallback(PARSE_ELEMENT_CALLBACK Callback, void *Data);
HRESULT clearGlobals(bool includingNatives = false);
HRESULT tickUnbreakable();
HRESULT removeFinishedScripts();
bool isValidScript(CScScript *script);
void setCompileErrorCallback(COMPILE_ERROR_CALLBACK callback, void *data);
void setParseElementCallback(PARSE_ELEMENT_CALLBACK callback, void *data);
COMPILE_ERROR_CALLBACK _compileErrorCallback;
void *_compileErrorCallbackData;
@ -116,30 +116,30 @@ public:
PARSE_ELEMENT_CALLBACK _parseElementCallback;
void *_parseElementCallbackData;
HRESULT SetFileToCompile(const char *filename);
HRESULT setFileToCompile(const char *filename);
char *_fileToCompile;
CScScript *_currentScript;
HRESULT ResumeAll();
HRESULT PauseAll();
HRESULT resumeAll();
HRESULT pauseAll();
void editorCleanup();
HRESULT ResetObject(CBObject *Object);
HRESULT ResetScript(CScScript *script);
HRESULT EmptyScriptCache();
byte *GetCompiledScript(const char *filename, uint32 *OutSize, bool IgnoreCache = false);
HRESULT resetObject(CBObject *Object);
HRESULT resetScript(CScScript *script);
HRESULT emptyScriptCache();
byte *getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache = false);
DECLARE_PERSISTENT(CScEngine, CBBase)
HRESULT cleanup();
int GetNumScripts(int *Running = NULL, int *Waiting = NULL, int *Persistent = NULL);
HRESULT Tick();
int getNumScripts(int *running = NULL, int *waiting = NULL, int *persistent = NULL);
HRESULT tick();
CScValue *_globals;
CScScript *RunScript(const char *filename, CBScriptHolder *Owner = NULL);
CScScript *runScript(const char *filename, CBScriptHolder *owner = NULL);
bool _compilerAvailable;
HINSTANCE _compilerDLL;
CScEngine(CBGame *inGame);
virtual ~CScEngine();
static void WINAPI AddError(void *Data, int Line, char *Text);
static byte *WINAPI loadFile(void *Data, char *Filename, uint32 *Size);
static void WINAPI CloseFile(void *Data, byte *Buffer);
static void WINAPI ParseElement(void *Data, int Line, int Type, void *ElementData);
static void addError(void *data, int line, char *text);
static byte *loadFile(void *data, char *filename, uint32 *size);
static void closeFile(void *data, byte *buffer);
static void parseElement(void *data, int line, int type, void *elementData);
DLL_COMPILE_BUFFER ExtCompileBuffer;
DLL_COMPILE_FILE ExtCompileFile;
DLL_RELEASE_BUFFER ExtReleaseBuffer;
@ -149,14 +149,14 @@ public:
CBArray<CScScript *, CScScript *> _scripts;
void EnableProfiling();
void DisableProfiling();
bool IsProfiling() {
void enableProfiling();
void disableProfiling();
bool isProfiling() {
return _isProfiling;
}
void AddScriptTime(const char *filename, uint32 Time);
void DumpStats();
void addScriptTime(const char *filename, uint32 Time);
void dumpStats();
private:

6
engines/wintermute/Base/scriptables/ScScript.cpp
View File

@ -154,7 +154,7 @@ HRESULT CScScript::InitScript() {
_currentLine = 0;
// init breakpoints
_engine->RefreshScriptBreakpoints(this);
_engine->refreshScriptBreakpoints(this);
// ready to rumble...
@ -1124,7 +1124,7 @@ HRESULT CScScript::WaitFor(CBObject *Object) {
//////////////////////////////////////////////////////////////////////////
HRESULT CScScript::WaitForExclusive(CBObject *Object) {
_engine->ResetObject(Object);
_engine->resetObject(Object);
return WaitFor(Object);
}
@ -1619,7 +1619,7 @@ bool CScScript::dbgGetTracingMode() {
//////////////////////////////////////////////////////////////////////////
void CScScript::afterLoad() {
if (_buffer == NULL) {
byte *buffer = _engine->GetCompiledScript(_filename, &_bufferSize);
byte *buffer = _engine->getCompiledScript(_filename, &_bufferSize);
if (!buffer) {
Game->LOG(0, "Error reinitializing script '%s' after load. Script will be terminated.", _filename);
_state = SCRIPT_ERROR;

2
engines/wintermute/wintermute.cpp
View File

@ -201,7 +201,7 @@ int WinterMuteEngine::init() {
_game->initialize2();
_game->getDebugMgr()->onGameInit();
_game->_scEngine->LoadBreakpoints();
_game->_scEngine->loadBreakpoints();