From 5683f076331d2831eb4720b65bb53e8d01ca33ee Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sat, 21 Jul 2012 18:19:07 +0200
Subject: WINTERMUTE: Rename CamelCased filenames to
 prefixed_under_score-filenames

This is mostly a lead-up to namespacing the Ad/Base folders, and then
possibly removing the prefixes from the files, it also has the added
benefit of getting rid of the odd case-typos that makes for issues
on platforms that don't ignore case.
---
 .../wintermute/base/scriptables/script_engine.cpp  | 712 +++++++++++++++++++++
 1 file changed, 712 insertions(+)
 create mode 100644 engines/wintermute/base/scriptables/script_engine.cpp

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
new file mode 100644
index 0000000000..387093ac4a
--- /dev/null
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -0,0 +1,712 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "engines/wintermute/dcgf.h"
+#include "engines/wintermute/base/scriptables/script_engine.h"
+#include "engines/wintermute/utils/string_util.h"
+#include "engines/wintermute/base/scriptables/script_value.h"
+#include "engines/wintermute/base/scriptables/script.h"
+#include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/base/scriptables/script_ext_math.h"
+#include "engines/wintermute/base/base_registry.h"
+#include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/sound/base_sound.h"
+#include "engines/wintermute/base/base_file_manager.h"
+
+
+namespace WinterMute {
+
+IMPLEMENT_PERSISTENT(CScEngine, true)
+
+#define COMPILER_DLL "dcscomp.dll"
+//////////////////////////////////////////////////////////////////////////
+CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) {
+	_gameRef->LOG(0, "Initializing scripting engine...");
+
+	if (_compilerAvailable) _gameRef->LOG(0, "  Script compiler bound successfuly");
+	else _gameRef->LOG(0, "  Script compiler is NOT available");
+
+	_globals = new CScValue(_gameRef);
+
+
+	// register 'Game' as global variable
+	if (!_globals->propExists("Game")) {
+		CScValue val(_gameRef);
+		val.setNative(_gameRef,  true);
+		_globals->setProp("Game", &val);
+	}
+
+	// register 'Math' as global variable
+	if (!_globals->propExists("Math")) {
+		CScValue val(_gameRef);
+		val.setNative(_gameRef->_mathClass, true);
+		_globals->setProp("Math", &val);
+	}
+
+	// prepare script cache
+	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) _cachedScripts[i] = NULL;
+
+	_currentScript = NULL;
+
+	_isProfiling = false;
+	_profilingStartTime = 0;
+
+	//EnableProfiling();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+CScEngine::~CScEngine() {
+	_gameRef->LOG(0, "Shutting down scripting engine");
+	saveBreakpoints();
+
+	disableProfiling();
+
+	cleanup();
+
+	for (int i = 0; i < _breakpoints.getSize(); i++) {
+		delete _breakpoints[i];
+		_breakpoints[i] = NULL;
+	}
+	_breakpoints.removeAll();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::cleanup() {
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->removeScript(_scripts[i]);
+		delete _scripts[i];
+		_scripts.removeAt(i);
+		i--;
+	}
+
+	_scripts.removeAll();
+
+	delete _globals;
+	_globals = NULL;
+
+	emptyScriptCache();
+
+	_currentScript = NULL; // ref only
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+byte *CScEngine::loadFile(void *data, char *filename, uint32 *size) {
+	CBGame *gameRef = (CBGame *)data;
+	return gameRef->_fileManager->readWholeFile(filename, size);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::closeFile(void *data, byte *buffer) {
+	delete [] buffer;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::parseElement(void *data, int line, int type, void *elementData) {
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
+	byte *compBuffer;
+	uint32 compSize;
+
+	// get script from cache
+	compBuffer = getCompiledScript(filename, &compSize);
+	if (!compBuffer) return NULL;
+
+	// add new script
+	CScScript *script = new CScScript(_gameRef, this);
+	bool ret = script->create(filename, compBuffer, compSize, owner);
+	if (DID_FAIL(ret)) {
+		_gameRef->LOG(ret, "Error running script '%s'...", filename);
+		delete script;
+		return NULL;
+	} else {
+		// publish the "self" pseudo-variable
+		CScValue val(_gameRef);
+		if (owner)val.setNative(owner, true);
+		else val.setNULL();
+
+		script->_globals->setProp("self", &val);
+		script->_globals->setProp("this", &val);
+
+		_scripts.add(script);
+		_gameRef->getDebugMgr()->onScriptInit(script);
+
+		return script;
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
+	// is script in cache?
+	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;
+				return _cachedScripts[i]->_buffer;
+			}
+		}
+	}
+
+	// nope, load it
+	byte *compBuffer;
+	uint32 compSize;
+
+	uint32 size;
+
+	byte *buffer = _gameRef->_fileManager->readWholeFile(filename, &size);
+	if (!buffer) {
+		_gameRef->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;
+	} else {
+		if (!_compilerAvailable) {
+			_gameRef->LOG(0, "CScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
+			delete [] buffer;
+			return NULL;
+		}
+		// This code will never be called, since _compilerAvailable is const false.
+		// It's only here in the event someone would want to reinclude the compiler.
+		error("Script needs compilation, ScummVM does not contain a WME compiler");
+	}
+
+	byte *ret = NULL;
+
+	// add script to cache
+	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
+	if (cachedScript) {
+		int index = 0;
+		uint32 MinTime = CBPlatform::getTime();
+		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+			if (_cachedScripts[i] == NULL) {
+				index = i;
+				break;
+			} else if (_cachedScripts[i]->_timestamp <= MinTime) {
+				MinTime = _cachedScripts[i]->_timestamp;
+				index = i;
+			}
+		}
+
+		if (_cachedScripts[index] != NULL) delete _cachedScripts[index];
+		_cachedScripts[index] = cachedScript;
+
+		ret = cachedScript->_buffer;
+		*outSize = cachedScript->_size;
+	}
+
+
+	// cleanup
+	delete [] buffer;
+
+	return ret;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::tick() {
+	if (_scripts.getSize() == 0)
+		return STATUS_OK;
+
+
+	// resolve waiting scripts
+	for (int i = 0; i < _scripts.getSize(); i++) {
+
+		switch (_scripts[i]->_state) {
+		case SCRIPT_WAITING: {
+			/*
+			bool obj_found=false;
+			for(int j=0; j<_gameRef->_regObjects.getSize(); j++)
+			{
+			    if(_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
+			    {
+			        if(_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
+			        obj_found = true;
+			        break;
+			    }
+			}
+			if(!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
+			*/
+			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
+				if (_scripts[i]->_waitObject->isReady()) _scripts[i]->run();
+			} else _scripts[i]->finish();
+			break;
+		}
+
+		case SCRIPT_SLEEPING: {
+			if (_scripts[i]->_waitFrozen) {
+				if (_scripts[i]->_waitTime <= CBPlatform::getTime()) _scripts[i]->run();
+			} else {
+				if (_scripts[i]->_waitTime <= _gameRef->_timer) _scripts[i]->run();
+			}
+			break;
+		}
+
+		case SCRIPT_WAITING_SCRIPT: {
+			if (!isValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
+				// fake return value
+				_scripts[i]->_stack->pushNULL();
+				_scripts[i]->_waitScript = NULL;
+				_scripts[i]->run();
+			} else {
+				if (_scripts[i]->_waitScript->_state == SCRIPT_THREAD_FINISHED) {
+					// copy return value
+					_scripts[i]->_stack->push(_scripts[i]->_waitScript->_stack->pop());
+					_scripts[i]->run();
+					_scripts[i]->_waitScript->finish();
+					_scripts[i]->_waitScript = NULL;
+				}
+			}
+			break;
+		}
+		default:
+			//warning("CScEngine::Tick - Unhandled enum");
+			break;
+		} // switch
+	} // for each script
+
+
+	// execute scripts
+	for (int i = 0; i < _scripts.getSize(); i++) {
+
+		// skip paused scripts
+		if (_scripts[i]->_state == SCRIPT_PAUSED) continue;
+
+		// time sliced script
+		if (_scripts[i]->_timeSlice > 0) {
+			uint32 StartTime = CBPlatform::getTime();
+			while (_scripts[i]->_state == SCRIPT_RUNNING && CBPlatform::getTime() - StartTime < _scripts[i]->_timeSlice) {
+				_currentScript = _scripts[i];
+				_scripts[i]->executeInstruction();
+			}
+			if (_isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, CBPlatform::getTime() - StartTime);
+		}
+
+		// normal script
+		else {
+			uint32 startTime = 0;
+			bool isProfiling = _isProfiling;
+			if (isProfiling) startTime = CBPlatform::getTime();
+
+			while (_scripts[i]->_state == SCRIPT_RUNNING) {
+				_currentScript = _scripts[i];
+				_scripts[i]->executeInstruction();
+			}
+			if (isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, CBPlatform::getTime() - startTime);
+		}
+		_currentScript = NULL;
+	}
+
+	removeFinishedScripts();
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::tickUnbreakable() {
+	// execute unbreakable scripts
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (!_scripts[i]->_unbreakable) continue;
+
+		while (_scripts[i]->_state == SCRIPT_RUNNING) {
+			_currentScript = _scripts[i];
+			_scripts[i]->executeInstruction();
+		}
+		_scripts[i]->finish();
+		_currentScript = NULL;
+	}
+	removeFinishedScripts();
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::removeFinishedScripts() {
+	// remove finished scripts
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
+			if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->removeScript(_scripts[i]);
+			_gameRef->getDebugMgr()->onScriptShutdown(_scripts[i]);
+			delete _scripts[i];
+			_scripts.removeAt(i);
+			i--;
+		}
+	}
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+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;
+		switch (_scripts[i]->_state) {
+		case SCRIPT_RUNNING:
+		case SCRIPT_SLEEPING:
+		case SCRIPT_PAUSED:
+			numRunning++;
+			break;
+		case SCRIPT_WAITING:
+			numWaiting++;
+			break;
+		case SCRIPT_PERSISTENT:
+			numPersistent++;
+			break;
+		default:
+			warning("CScEngine::GetNumScripts - unhandled enum");
+			break;
+		}
+		numTotal++;
+	}
+	if (running) *running = numRunning;
+	if (waiting) *waiting = numWaiting;
+	if (persistent)  *persistent = numPersistent;
+
+	return numTotal;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::emptyScriptCache() {
+	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+		if (_cachedScripts[i]) {
+			delete _cachedScripts[i];
+			_cachedScripts[i] = NULL;
+		}
+	}
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool 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 (!_gameRef->_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
+		}
+	}
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool 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) {
+			_scripts[i]->finish();
+		}
+	}
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::persist(CBPersistMgr *persistMgr) {
+	if (!persistMgr->_saving) cleanup();
+
+	persistMgr->transfer(TMEMBER(_gameRef));
+	persistMgr->transfer(TMEMBER(_currentScript));
+	persistMgr->transfer(TMEMBER(_globals));
+	_scripts.persist(persistMgr);
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::editorCleanup() {
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
+			delete _scripts[i];
+			_scripts.removeAt(i);
+			i--;
+		}
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::pauseAll() {
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (_scripts[i] != _currentScript) _scripts[i]->pause();
+	}
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::resumeAll() {
+	for (int i = 0; i < _scripts.getSize(); i++)
+		_scripts[i]->resume();
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::isValidScript(CScScript *script) {
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (_scripts[i] == script) return true;
+	}
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::clearGlobals(bool includingNatives) {
+	_globals->CleanProps(includingNatives);
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::dbgSendScripts(IWmeDebugClient *client) {
+	// send global variables
+	_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);
+	}
+
+	// and threads later
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		if (_scripts[i]->_thread || _scripts[i]->_methodThread)
+			_scripts[i]->dbgSendScript(client);
+	}
+
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::addBreakpoint(const char *scriptFilename, int line) {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+	CScBreakpoint *bp = NULL;
+	for (int i = 0; i < _breakpoints.getSize(); 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);
+	}
+
+	for (int i = 0; i < bp->_lines.getSize(); i++) {
+		if (bp->_lines[i] == line) return STATUS_OK;
+	}
+	bp->_lines.add(line);
+
+	// refresh changes
+	refreshScriptBreakpoints();
+
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::removeBreakpoint(const char *scriptFilename, int line) {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+	for (int i = 0; i < _breakpoints.getSize(); i++) {
+		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) {
+					_breakpoints[i]->_lines.removeAt(j);
+					if (_breakpoints[i]->_lines.getSize() == 0) {
+						delete _breakpoints[i];
+						_breakpoints.removeAt(i);
+					}
+					// refresh changes
+					refreshScriptBreakpoints();
+
+					return STATUS_OK;
+				}
+			}
+			break;
+		}
+	}
+	return STATUS_FAILED;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::refreshScriptBreakpoints() {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+	for (int i = 0; i < _scripts.getSize(); i++) {
+		refreshScriptBreakpoints(_scripts[i]);
+	}
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::refreshScriptBreakpoints(CScScript *script) {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+	if (!script || !script->_filename) return STATUS_FAILED;
+
+	for (int i = 0; i < _breakpoints.getSize(); i++) {
+		if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), script->_filename) == 0) {
+			script->_breakpoints.copy(_breakpoints[i]->_lines);
+			return STATUS_OK;
+		}
+	}
+	if (script->_breakpoints.getSize() > 0) script->_breakpoints.removeAll();
+
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::saveBreakpoints() {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+
+	char text[512];
+	char key[100];
+
+	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]);
+
+			_gameRef->_registry->writeString("Debug", key, text);
+		}
+	}
+	_gameRef->_registry->writeInt("Debug", "NumBreakpoints", count);
+
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool CScEngine::loadBreakpoints() {
+	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+
+	char key[100];
+
+	int count = _gameRef->_registry->readInt("Debug", "NumBreakpoints", 0);
+	for (int i = 1; i <= count; i++) {
+		/*  uint32 BufSize = 512; */
+		sprintf(key, "Breakpoint%d", i);
+		AnsiString breakpoint = _gameRef->_registry->readString("Debug", key, "");
+
+		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;
+	}
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::addScriptTime(const char *filename, uint32 time) {
+	if (!_isProfiling) return;
+
+	AnsiString fileName = filename;
+	fileName.toLowercase();
+	_scriptTimes[fileName] += time;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::enableProfiling() {
+	if (_isProfiling) return;
+
+	// destroy old data, if any
+	_scriptTimes.clear();
+
+	_profilingStartTime = CBPlatform::getTime();
+	_isProfiling = true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::disableProfiling() {
+	if (!_isProfiling) return;
+
+	dumpStats();
+	_isProfiling = false;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void CScEngine::dumpStats() {
+	error("DumpStats not ported to ScummVM yet");
+	/*  uint32 totalTime = CBPlatform::getTime() - _profilingStartTime;
+
+	    typedef std::vector <std::pair<uint32, std::string> > TimeVector;
+	    TimeVector times;
+
+	    ScriptTimes::iterator it;
+	    for (it = _scriptTimes.begin(); it != _scriptTimes.end(); it++) {
+	        times.push_back(std::pair<uint32, std::string> (it->_value, it->_key));
+	    }
+	    std::sort(times.begin(), times.end());
+
+
+	    TimeVector::reverse_iterator tit;
+
+	    _gameRef->LOG(0, "***** Script profiling information: *****");
+	    _gameRef->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
+
+	    for (tit = times.rbegin(); tit != times.rend(); tit++) {
+	        _gameRef->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
+	    }*/
+}
+
+} // end of namespace WinterMute
-- 
cgit v1.2.3


From b5a07fef8ebf29f7f44b15d9b34799c7e115fdad Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sat, 21 Jul 2012 21:01:47 +0200
Subject: WINTERMUTE: Get rid of the C-prefix for class-definitions.

---
 .../wintermute/base/scriptables/script_engine.cpp  | 110 ++++++++++-----------
 1 file changed, 55 insertions(+), 55 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 387093ac4a..44add054c5 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -41,29 +41,29 @@
 
 namespace WinterMute {
 
-IMPLEMENT_PERSISTENT(CScEngine, true)
+IMPLEMENT_PERSISTENT(ScEngine, true)
 
 #define COMPILER_DLL "dcscomp.dll"
 //////////////////////////////////////////////////////////////////////////
-CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) {
+ScEngine::ScEngine(BaseGame *inGame): BaseClass(inGame) {
 	_gameRef->LOG(0, "Initializing scripting engine...");
 
 	if (_compilerAvailable) _gameRef->LOG(0, "  Script compiler bound successfuly");
 	else _gameRef->LOG(0, "  Script compiler is NOT available");
 
-	_globals = new CScValue(_gameRef);
+	_globals = new ScValue(_gameRef);
 
 
 	// register 'Game' as global variable
 	if (!_globals->propExists("Game")) {
-		CScValue val(_gameRef);
+		ScValue val(_gameRef);
 		val.setNative(_gameRef,  true);
 		_globals->setProp("Game", &val);
 	}
 
 	// register 'Math' as global variable
 	if (!_globals->propExists("Math")) {
-		CScValue val(_gameRef);
+		ScValue val(_gameRef);
 		val.setNative(_gameRef->_mathClass, true);
 		_globals->setProp("Math", &val);
 	}
@@ -81,7 +81,7 @@ CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) {
 
 
 //////////////////////////////////////////////////////////////////////////
-CScEngine::~CScEngine() {
+ScEngine::~ScEngine() {
 	_gameRef->LOG(0, "Shutting down scripting engine");
 	saveBreakpoints();
 
@@ -98,7 +98,7 @@ CScEngine::~CScEngine() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::cleanup() {
+bool ScEngine::cleanup() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->removeScript(_scripts[i]);
 		delete _scripts[i];
@@ -120,25 +120,25 @@ bool CScEngine::cleanup() {
 
 
 //////////////////////////////////////////////////////////////////////////
-byte *CScEngine::loadFile(void *data, char *filename, uint32 *size) {
-	CBGame *gameRef = (CBGame *)data;
+byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
+	BaseGame *gameRef = (BaseGame *)data;
 	return gameRef->_fileManager->readWholeFile(filename, size);
 }
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::closeFile(void *data, byte *buffer) {
+void ScEngine::closeFile(void *data, byte *buffer) {
 	delete [] buffer;
 }
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::parseElement(void *data, int line, int type, void *elementData) {
+void ScEngine::parseElement(void *data, int line, int type, void *elementData) {
 }
 
 
 //////////////////////////////////////////////////////////////////////////
-CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
+ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
 	byte *compBuffer;
 	uint32 compSize;
 
@@ -147,7 +147,7 @@ CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
 	if (!compBuffer) return NULL;
 
 	// add new script
-	CScScript *script = new CScScript(_gameRef, this);
+	ScScript *script = new ScScript(_gameRef, this);
 	bool ret = script->create(filename, compBuffer, compSize, owner);
 	if (DID_FAIL(ret)) {
 		_gameRef->LOG(ret, "Error running script '%s'...", filename);
@@ -155,7 +155,7 @@ CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
 		return NULL;
 	} else {
 		// publish the "self" pseudo-variable
-		CScValue val(_gameRef);
+		ScValue val(_gameRef);
 		if (owner)val.setNative(owner, true);
 		else val.setNULL();
 
@@ -171,12 +171,12 @@ CScScript *CScEngine::runScript(const char *filename, CBScriptHolder *owner) {
 
 
 //////////////////////////////////////////////////////////////////////////
-byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
+byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
 	// is script in cache?
 	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();
+				_cachedScripts[i]->_timestamp = BasePlatform::getTime();
 				*outSize = _cachedScripts[i]->_size;
 				return _cachedScripts[i]->_buffer;
 			}
@@ -191,7 +191,7 @@ byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool i
 
 	byte *buffer = _gameRef->_fileManager->readWholeFile(filename, &size);
 	if (!buffer) {
-		_gameRef->LOG(0, "CScEngine::GetCompiledScript - error opening script '%s'", filename);
+		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
 		return NULL;
 	}
 
@@ -201,7 +201,7 @@ byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool i
 		compSize = size;
 	} else {
 		if (!_compilerAvailable) {
-			_gameRef->LOG(0, "CScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
+			_gameRef->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
 			delete [] buffer;
 			return NULL;
 		}
@@ -216,7 +216,7 @@ byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool i
 	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
 	if (cachedScript) {
 		int index = 0;
-		uint32 MinTime = CBPlatform::getTime();
+		uint32 MinTime = BasePlatform::getTime();
 		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
 			if (_cachedScripts[i] == NULL) {
 				index = i;
@@ -244,7 +244,7 @@ byte *CScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool i
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::tick() {
+bool ScEngine::tick() {
 	if (_scripts.getSize() == 0)
 		return STATUS_OK;
 
@@ -275,7 +275,7 @@ bool CScEngine::tick() {
 
 		case SCRIPT_SLEEPING: {
 			if (_scripts[i]->_waitFrozen) {
-				if (_scripts[i]->_waitTime <= CBPlatform::getTime()) _scripts[i]->run();
+				if (_scripts[i]->_waitTime <= BasePlatform::getTime()) _scripts[i]->run();
 			} else {
 				if (_scripts[i]->_waitTime <= _gameRef->_timer) _scripts[i]->run();
 			}
@@ -300,7 +300,7 @@ bool CScEngine::tick() {
 			break;
 		}
 		default:
-			//warning("CScEngine::Tick - Unhandled enum");
+			//warning("ScEngine::Tick - Unhandled enum");
 			break;
 		} // switch
 	} // for each script
@@ -314,25 +314,25 @@ bool CScEngine::tick() {
 
 		// time sliced script
 		if (_scripts[i]->_timeSlice > 0) {
-			uint32 StartTime = CBPlatform::getTime();
-			while (_scripts[i]->_state == SCRIPT_RUNNING && CBPlatform::getTime() - StartTime < _scripts[i]->_timeSlice) {
+			uint32 StartTime = BasePlatform::getTime();
+			while (_scripts[i]->_state == SCRIPT_RUNNING && BasePlatform::getTime() - StartTime < _scripts[i]->_timeSlice) {
 				_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, BasePlatform::getTime() - StartTime);
 		}
 
 		// normal script
 		else {
 			uint32 startTime = 0;
 			bool isProfiling = _isProfiling;
-			if (isProfiling) startTime = CBPlatform::getTime();
+			if (isProfiling) startTime = BasePlatform::getTime();
 
 			while (_scripts[i]->_state == SCRIPT_RUNNING) {
 				_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, BasePlatform::getTime() - startTime);
 		}
 		_currentScript = NULL;
 	}
@@ -344,7 +344,7 @@ bool CScEngine::tick() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::tickUnbreakable() {
+bool ScEngine::tickUnbreakable() {
 	// execute unbreakable scripts
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (!_scripts[i]->_unbreakable) continue;
@@ -363,7 +363,7 @@ bool CScEngine::tickUnbreakable() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::removeFinishedScripts() {
+bool ScEngine::removeFinishedScripts() {
 	// remove finished scripts
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
@@ -379,7 +379,7 @@ bool CScEngine::removeFinishedScripts() {
 
 
 //////////////////////////////////////////////////////////////////////////
-int CScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
+int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 	int numRunning = 0, numWaiting = 0, numPersistent = 0, numTotal = 0;
 
 	for (int i = 0; i < _scripts.getSize(); i++) {
@@ -397,7 +397,7 @@ int CScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 			numPersistent++;
 			break;
 		default:
-			warning("CScEngine::GetNumScripts - unhandled enum");
+			warning("ScEngine::GetNumScripts - unhandled enum");
 			break;
 		}
 		numTotal++;
@@ -411,7 +411,7 @@ int CScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::emptyScriptCache() {
+bool ScEngine::emptyScriptCache() {
 	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
 		if (_cachedScripts[i]) {
 			delete _cachedScripts[i];
@@ -423,7 +423,7 @@ bool CScEngine::emptyScriptCache() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::resetObject(CBObject *Object) {
+bool ScEngine::resetObject(BaseObject *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) {
@@ -437,7 +437,7 @@ bool CScEngine::resetObject(CBObject *Object) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::resetScript(CScScript *script) {
+bool ScEngine::resetScript(ScScript *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) {
@@ -448,7 +448,7 @@ bool CScEngine::resetScript(CScScript *script) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::persist(CBPersistMgr *persistMgr) {
+bool ScEngine::persist(BasePersistenceManager *persistMgr) {
 	if (!persistMgr->_saving) cleanup();
 
 	persistMgr->transfer(TMEMBER(_gameRef));
@@ -461,7 +461,7 @@ bool CScEngine::persist(CBPersistMgr *persistMgr) {
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::editorCleanup() {
+void ScEngine::editorCleanup() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
 			delete _scripts[i];
@@ -473,7 +473,7 @@ void CScEngine::editorCleanup() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::pauseAll() {
+bool ScEngine::pauseAll() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i] != _currentScript) _scripts[i]->pause();
 	}
@@ -483,7 +483,7 @@ bool CScEngine::pauseAll() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::resumeAll() {
+bool ScEngine::resumeAll() {
 	for (int i = 0; i < _scripts.getSize(); i++)
 		_scripts[i]->resume();
 
@@ -492,7 +492,7 @@ bool CScEngine::resumeAll() {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::isValidScript(CScScript *script) {
+bool ScEngine::isValidScript(ScScript *script) {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i] == script) return true;
 	}
@@ -500,13 +500,13 @@ bool CScEngine::isValidScript(CScScript *script) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::clearGlobals(bool includingNatives) {
+bool ScEngine::clearGlobals(bool includingNatives) {
 	_globals->CleanProps(includingNatives);
 	return STATUS_OK;
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::dbgSendScripts(IWmeDebugClient *client) {
+bool ScEngine::dbgSendScripts(IWmeDebugClient *client) {
 	// send global variables
 	_globals->dbgSendVariables(client, WME_DBGVAR_GLOBAL, NULL, 0);
 
@@ -526,7 +526,7 @@ bool CScEngine::dbgSendScripts(IWmeDebugClient *client) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::addBreakpoint(const char *scriptFilename, int line) {
+bool ScEngine::addBreakpoint(const char *scriptFilename, int line) {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 	CScBreakpoint *bp = NULL;
@@ -553,7 +553,7 @@ bool CScEngine::addBreakpoint(const char *scriptFilename, int line) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::removeBreakpoint(const char *scriptFilename, int line) {
+bool ScEngine::removeBreakpoint(const char *scriptFilename, int line) {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 	for (int i = 0; i < _breakpoints.getSize(); i++) {
@@ -578,7 +578,7 @@ bool CScEngine::removeBreakpoint(const char *scriptFilename, int line) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::refreshScriptBreakpoints() {
+bool ScEngine::refreshScriptBreakpoints() {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 	for (int i = 0; i < _scripts.getSize(); i++) {
@@ -588,7 +588,7 @@ bool CScEngine::refreshScriptBreakpoints() {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::refreshScriptBreakpoints(CScScript *script) {
+bool ScEngine::refreshScriptBreakpoints(ScScript *script) {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 	if (!script || !script->_filename) return STATUS_FAILED;
@@ -605,7 +605,7 @@ bool CScEngine::refreshScriptBreakpoints(CScScript *script) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::saveBreakpoints() {
+bool ScEngine::saveBreakpoints() {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 
@@ -628,7 +628,7 @@ bool CScEngine::saveBreakpoints() {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool CScEngine::loadBreakpoints() {
+bool ScEngine::loadBreakpoints() {
 	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
 
 	char key[100];
@@ -639,8 +639,8 @@ bool CScEngine::loadBreakpoints() {
 		sprintf(key, "Breakpoint%d", i);
 		AnsiString breakpoint = _gameRef->_registry->readString("Debug", key, "");
 
-		char *path = CBUtils::strEntry(0, breakpoint.c_str(), ':');
-		char *line = CBUtils::strEntry(1, breakpoint.c_str(), ':');
+		char *path = BaseUtils::strEntry(0, breakpoint.c_str(), ':');
+		char *line = BaseUtils::strEntry(1, breakpoint.c_str(), ':');
 
 		if (path != NULL && line != NULL) addBreakpoint(path, atoi(line));
 		delete[] path;
@@ -654,7 +654,7 @@ bool CScEngine::loadBreakpoints() {
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::addScriptTime(const char *filename, uint32 time) {
+void ScEngine::addScriptTime(const char *filename, uint32 time) {
 	if (!_isProfiling) return;
 
 	AnsiString fileName = filename;
@@ -664,19 +664,19 @@ void CScEngine::addScriptTime(const char *filename, uint32 time) {
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::enableProfiling() {
+void ScEngine::enableProfiling() {
 	if (_isProfiling) return;
 
 	// destroy old data, if any
 	_scriptTimes.clear();
 
-	_profilingStartTime = CBPlatform::getTime();
+	_profilingStartTime = BasePlatform::getTime();
 	_isProfiling = true;
 }
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::disableProfiling() {
+void ScEngine::disableProfiling() {
 	if (!_isProfiling) return;
 
 	dumpStats();
@@ -685,9 +685,9 @@ void CScEngine::disableProfiling() {
 
 
 //////////////////////////////////////////////////////////////////////////
-void CScEngine::dumpStats() {
+void ScEngine::dumpStats() {
 	error("DumpStats not ported to ScummVM yet");
-	/*  uint32 totalTime = CBPlatform::getTime() - _profilingStartTime;
+	/*  uint32 totalTime = BasePlatform::getTime() - _profilingStartTime;
 
 	    typedef std::vector <std::pair<uint32, std::string> > TimeVector;
 	    TimeVector times;
-- 
cgit v1.2.3


From 7a818009b4c20df1811c0b158b0f8acfe0e3d208 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Mon, 23 Jul 2012 02:23:14 +0200
Subject: WINTERMUTE: Clean out unused utils.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 44add054c5..e8544d8cd6 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -37,7 +37,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/sound/base_sound.h"
 #include "engines/wintermute/base/base_file_manager.h"
-
+#include "engines/wintermute/utils/utils.h"
 
 namespace WinterMute {
 
-- 
cgit v1.2.3


From 448911930d8d6bf43a67769d50ee4048f296b7f4 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Mon, 23 Jul 2012 03:01:05 +0200
Subject: WINTERMUTE: Remove unused code from platform_osystem.h

---
 .../wintermute/base/scriptables/script_engine.cpp    | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index e8544d8cd6..472e9d9fec 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -176,7 +176,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 	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 = BasePlatform::getTime();
+				_cachedScripts[i]->_timestamp = g_system->getMillis();
 				*outSize = _cachedScripts[i]->_size;
 				return _cachedScripts[i]->_buffer;
 			}
@@ -216,7 +216,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
 	if (cachedScript) {
 		int index = 0;
-		uint32 MinTime = BasePlatform::getTime();
+		uint32 MinTime = g_system->getMillis();
 		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
 			if (_cachedScripts[i] == NULL) {
 				index = i;
@@ -275,7 +275,7 @@ bool ScEngine::tick() {
 
 		case SCRIPT_SLEEPING: {
 			if (_scripts[i]->_waitFrozen) {
-				if (_scripts[i]->_waitTime <= BasePlatform::getTime()) _scripts[i]->run();
+				if (_scripts[i]->_waitTime <= g_system->getMillis()) _scripts[i]->run();
 			} else {
 				if (_scripts[i]->_waitTime <= _gameRef->_timer) _scripts[i]->run();
 			}
@@ -314,25 +314,25 @@ bool ScEngine::tick() {
 
 		// time sliced script
 		if (_scripts[i]->_timeSlice > 0) {
-			uint32 StartTime = BasePlatform::getTime();
-			while (_scripts[i]->_state == SCRIPT_RUNNING && BasePlatform::getTime() - StartTime < _scripts[i]->_timeSlice) {
+			uint32 StartTime = g_system->getMillis();
+			while (_scripts[i]->_state == SCRIPT_RUNNING && g_system->getMillis() - StartTime < _scripts[i]->_timeSlice) {
 				_currentScript = _scripts[i];
 				_scripts[i]->executeInstruction();
 			}
-			if (_isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, BasePlatform::getTime() - StartTime);
+			if (_isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, g_system->getMillis() - StartTime);
 		}
 
 		// normal script
 		else {
 			uint32 startTime = 0;
 			bool isProfiling = _isProfiling;
-			if (isProfiling) startTime = BasePlatform::getTime();
+			if (isProfiling) startTime = g_system->getMillis();
 
 			while (_scripts[i]->_state == SCRIPT_RUNNING) {
 				_currentScript = _scripts[i];
 				_scripts[i]->executeInstruction();
 			}
-			if (isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, BasePlatform::getTime() - startTime);
+			if (isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
 		}
 		_currentScript = NULL;
 	}
@@ -670,7 +670,7 @@ void ScEngine::enableProfiling() {
 	// destroy old data, if any
 	_scriptTimes.clear();
 
-	_profilingStartTime = BasePlatform::getTime();
+	_profilingStartTime = g_system->getMillis();
 	_isProfiling = true;
 }
 
@@ -687,7 +687,7 @@ void ScEngine::disableProfiling() {
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::dumpStats() {
 	error("DumpStats not ported to ScummVM yet");
-	/*  uint32 totalTime = BasePlatform::getTime() - _profilingStartTime;
+	/*  uint32 totalTime = g_system->getMillis() - _profilingStartTime;
 
 	    typedef std::vector <std::pair<uint32, std::string> > TimeVector;
 	    TimeVector times;
-- 
cgit v1.2.3


From aedb0aea505e764c4c7bab1f90520b380be4d688 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Mon, 23 Jul 2012 03:22:49 +0200
Subject: WINTERMUTE: Remove dcgf.h from almost all includes.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 472e9d9fec..c275ebf5af 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -26,7 +26,6 @@
  * Copyright (c) 2011 Jan Nedoma
  */
 
-#include "engines/wintermute/dcgf.h"
 #include "engines/wintermute/base/scriptables/script_engine.h"
 #include "engines/wintermute/utils/string_util.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
-- 
cgit v1.2.3


From c7eda9abc80d1912148cae4292b94620c67a9c19 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Mon, 23 Jul 2012 03:42:27 +0200
Subject: WINTERMUTE: Encapsulate and distance BasePersistenceManager from
 Base.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index c275ebf5af..59ec113d1f 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -448,7 +448,7 @@ bool ScEngine::resetScript(ScScript *script) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::persist(BasePersistenceManager *persistMgr) {
-	if (!persistMgr->_saving) cleanup();
+	if (!persistMgr->getIsSaving()) cleanup();
 
 	persistMgr->transfer(TMEMBER(_gameRef));
 	persistMgr->transfer(TMEMBER(_currentScript));
-- 
cgit v1.2.3


From fa96c9ea187cdb26e9f1ce048c9132f723e25df1 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Wed, 25 Jul 2012 21:05:03 +0200
Subject: WINTERMUTE: "delete []" -> "delete[]"

---
 engines/wintermute/base/scriptables/script_engine.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 59ec113d1f..c33d844aa1 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -127,7 +127,7 @@ byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
 
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::closeFile(void *data, byte *buffer) {
-	delete [] buffer;
+	delete[] buffer;
 }
 
 
@@ -201,7 +201,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 	} else {
 		if (!_compilerAvailable) {
 			_gameRef->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
-			delete [] buffer;
+			delete[] buffer;
 			return NULL;
 		}
 		// This code will never be called, since _compilerAvailable is const false.
@@ -235,7 +235,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 
 	// cleanup
-	delete [] buffer;
+	delete[] buffer;
 
 	return ret;
 }
-- 
cgit v1.2.3


From 1ad859a468415cc7fd93adaa84beba02aae29ad8 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Wed, 25 Jul 2012 21:21:55 +0200
Subject: WINTERMUTE: "if(" -> "if ("

---
 engines/wintermute/base/scriptables/script_engine.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index c33d844aa1..792dfd4589 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -257,14 +257,14 @@ bool ScEngine::tick() {
 			bool obj_found=false;
 			for(int j=0; j<_gameRef->_regObjects.getSize(); j++)
 			{
-			    if(_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
+			    if (_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
 			    {
-			        if(_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
+			        if (_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
 			        obj_found = true;
 			        break;
 			    }
 			}
-			if(!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
+			if (!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
 			*/
 			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
 				if (_scripts[i]->_waitObject->isReady()) _scripts[i]->run();
-- 
cgit v1.2.3


From ef11f9d0c53cbdd9d88a99143de6f43f34d7e24d Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Thu, 26 Jul 2012 15:59:26 +0200
Subject: WINTERMUTE: Run Astyle with add-braces to break one-line statements
 into easier-to-read-code.

---
 .../wintermute/base/scriptables/script_engine.cpp  | 167 +++++++++++++++------
 1 file changed, 124 insertions(+), 43 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 792dfd4589..356617094d 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -47,8 +47,11 @@ IMPLEMENT_PERSISTENT(ScEngine, true)
 ScEngine::ScEngine(BaseGame *inGame): BaseClass(inGame) {
 	_gameRef->LOG(0, "Initializing scripting engine...");
 
-	if (_compilerAvailable) _gameRef->LOG(0, "  Script compiler bound successfuly");
-	else _gameRef->LOG(0, "  Script compiler is NOT available");
+	if (_compilerAvailable) {
+		_gameRef->LOG(0, "  Script compiler bound successfuly");
+	} else {
+		_gameRef->LOG(0, "  Script compiler is NOT available");
+	}
 
 	_globals = new ScValue(_gameRef);
 
@@ -68,7 +71,9 @@ ScEngine::ScEngine(BaseGame *inGame): BaseClass(inGame) {
 	}
 
 	// prepare script cache
-	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) _cachedScripts[i] = NULL;
+	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+		_cachedScripts[i] = NULL;
+	}
 
 	_currentScript = NULL;
 
@@ -99,7 +104,9 @@ ScEngine::~ScEngine() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::cleanup() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->removeScript(_scripts[i]);
+		if (!_scripts[i]->_thread && _scripts[i]->_owner) {
+			_scripts[i]->_owner->removeScript(_scripts[i]);
+		}
 		delete _scripts[i];
 		_scripts.removeAt(i);
 		i--;
@@ -143,7 +150,9 @@ ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
 
 	// get script from cache
 	compBuffer = getCompiledScript(filename, &compSize);
-	if (!compBuffer) return NULL;
+	if (!compBuffer) {
+		return NULL;
+	}
 
 	// add new script
 	ScScript *script = new ScScript(_gameRef, this);
@@ -155,8 +164,11 @@ ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
 	} else {
 		// publish the "self" pseudo-variable
 		ScValue val(_gameRef);
-		if (owner)val.setNative(owner, true);
-		else val.setNULL();
+		if (owner) {
+			val.setNative(owner, true);
+		} else {
+			val.setNULL();
+		}
 
 		script->_globals->setProp("self", &val);
 		script->_globals->setProp("this", &val);
@@ -226,7 +238,9 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 			}
 		}
 
-		if (_cachedScripts[index] != NULL) delete _cachedScripts[index];
+		if (_cachedScripts[index] != NULL) {
+			delete _cachedScripts[index];
+		}
 		_cachedScripts[index] = cachedScript;
 
 		ret = cachedScript->_buffer;
@@ -244,8 +258,9 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::tick() {
-	if (_scripts.getSize() == 0)
+	if (_scripts.getSize() == 0) {
 		return STATUS_OK;
+	}
 
 
 	// resolve waiting scripts
@@ -267,16 +282,24 @@ bool ScEngine::tick() {
 			if (!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
 			*/
 			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
-				if (_scripts[i]->_waitObject->isReady()) _scripts[i]->run();
-			} else _scripts[i]->finish();
+				if (_scripts[i]->_waitObject->isReady()) {
+					_scripts[i]->run();
+				}
+			} else {
+				_scripts[i]->finish();
+			}
 			break;
 		}
 
 		case SCRIPT_SLEEPING: {
 			if (_scripts[i]->_waitFrozen) {
-				if (_scripts[i]->_waitTime <= g_system->getMillis()) _scripts[i]->run();
+				if (_scripts[i]->_waitTime <= g_system->getMillis()) {
+					_scripts[i]->run();
+				}
 			} else {
-				if (_scripts[i]->_waitTime <= _gameRef->_timer) _scripts[i]->run();
+				if (_scripts[i]->_waitTime <= _gameRef->_timer) {
+					_scripts[i]->run();
+				}
 			}
 			break;
 		}
@@ -309,7 +332,9 @@ bool ScEngine::tick() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 
 		// skip paused scripts
-		if (_scripts[i]->_state == SCRIPT_PAUSED) continue;
+		if (_scripts[i]->_state == SCRIPT_PAUSED) {
+			continue;
+		}
 
 		// time sliced script
 		if (_scripts[i]->_timeSlice > 0) {
@@ -318,20 +343,26 @@ bool ScEngine::tick() {
 				_currentScript = _scripts[i];
 				_scripts[i]->executeInstruction();
 			}
-			if (_isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, g_system->getMillis() - StartTime);
+			if (_isProfiling && _scripts[i]->_filename) {
+				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - StartTime);
+			}
 		}
 
 		// normal script
 		else {
 			uint32 startTime = 0;
 			bool isProfiling = _isProfiling;
-			if (isProfiling) startTime = g_system->getMillis();
+			if (isProfiling) {
+				startTime = g_system->getMillis();
+			}
 
 			while (_scripts[i]->_state == SCRIPT_RUNNING) {
 				_currentScript = _scripts[i];
 				_scripts[i]->executeInstruction();
 			}
-			if (isProfiling && _scripts[i]->_filename) addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
+			if (isProfiling && _scripts[i]->_filename) {
+				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
+			}
 		}
 		_currentScript = NULL;
 	}
@@ -346,7 +377,9 @@ bool ScEngine::tick() {
 bool ScEngine::tickUnbreakable() {
 	// execute unbreakable scripts
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (!_scripts[i]->_unbreakable) continue;
+		if (!_scripts[i]->_unbreakable) {
+			continue;
+		}
 
 		while (_scripts[i]->_state == SCRIPT_RUNNING) {
 			_currentScript = _scripts[i];
@@ -366,7 +399,9 @@ bool ScEngine::removeFinishedScripts() {
 	// remove finished scripts
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
-			if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->removeScript(_scripts[i]);
+			if (!_scripts[i]->_thread && _scripts[i]->_owner) {
+				_scripts[i]->_owner->removeScript(_scripts[i]);
+			}
 			_gameRef->getDebugMgr()->onScriptShutdown(_scripts[i]);
 			delete _scripts[i];
 			_scripts.removeAt(i);
@@ -382,7 +417,9 @@ int ScEngine::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;
+		if (_scripts[i]->_state == SCRIPT_FINISHED) {
+			continue;
+		}
 		switch (_scripts[i]->_state) {
 		case SCRIPT_RUNNING:
 		case SCRIPT_SLEEPING:
@@ -401,9 +438,15 @@ int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 		}
 		numTotal++;
 	}
-	if (running) *running = numRunning;
-	if (waiting) *waiting = numWaiting;
-	if (persistent)  *persistent = numPersistent;
+	if (running) {
+		*running = numRunning;
+	}
+	if (waiting) {
+		*waiting = numWaiting;
+	}
+	if (persistent) {
+		*persistent = numPersistent;
+	}
 
 	return numTotal;
 }
@@ -426,7 +469,9 @@ bool ScEngine::resetObject(BaseObject *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 (!_gameRef->_compatKillMethodThreads) resetScript(_scripts[i]);
+			if (!_gameRef->_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
@@ -448,7 +493,9 @@ bool ScEngine::resetScript(ScScript *script) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::persist(BasePersistenceManager *persistMgr) {
-	if (!persistMgr->getIsSaving()) cleanup();
+	if (!persistMgr->getIsSaving()) {
+		cleanup();
+	}
 
 	persistMgr->transfer(TMEMBER(_gameRef));
 	persistMgr->transfer(TMEMBER(_currentScript));
@@ -474,7 +521,9 @@ void ScEngine::editorCleanup() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::pauseAll() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (_scripts[i] != _currentScript) _scripts[i]->pause();
+		if (_scripts[i] != _currentScript) {
+			_scripts[i]->pause();
+		}
 	}
 
 	return STATUS_OK;
@@ -483,8 +532,9 @@ bool ScEngine::pauseAll() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::resumeAll() {
-	for (int i = 0; i < _scripts.getSize(); i++)
+	for (int i = 0; i < _scripts.getSize(); i++) {
 		_scripts[i]->resume();
+	}
 
 	return STATUS_OK;
 }
@@ -493,7 +543,9 @@ bool ScEngine::resumeAll() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::isValidScript(ScScript *script) {
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (_scripts[i] == script) return true;
+		if (_scripts[i] == script) {
+			return true;
+		}
 	}
 	return false;
 }
@@ -511,14 +563,17 @@ bool ScEngine::dbgSendScripts(IWmeDebugClient *client) {
 
 	// process normal scripts first
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (_scripts[i]->_thread || _scripts[i]->_methodThread) continue;
+		if (_scripts[i]->_thread || _scripts[i]->_methodThread) {
+			continue;
+		}
 		_scripts[i]->dbgSendScript(client);
 	}
 
 	// and threads later
 	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (_scripts[i]->_thread || _scripts[i]->_methodThread)
+		if (_scripts[i]->_thread || _scripts[i]->_methodThread) {
 			_scripts[i]->dbgSendScript(client);
+		}
 	}
 
 	return STATUS_OK;
@@ -526,7 +581,9 @@ bool ScEngine::dbgSendScripts(IWmeDebugClient *client) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::addBreakpoint(const char *scriptFilename, int line) {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
 	CScBreakpoint *bp = NULL;
 	for (int i = 0; i < _breakpoints.getSize(); i++) {
@@ -541,7 +598,9 @@ bool ScEngine::addBreakpoint(const char *scriptFilename, int line) {
 	}
 
 	for (int i = 0; i < bp->_lines.getSize(); i++) {
-		if (bp->_lines[i] == line) return STATUS_OK;
+		if (bp->_lines[i] == line) {
+			return STATUS_OK;
+		}
 	}
 	bp->_lines.add(line);
 
@@ -553,7 +612,9 @@ bool ScEngine::addBreakpoint(const char *scriptFilename, int line) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::removeBreakpoint(const char *scriptFilename, int line) {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
 	for (int i = 0; i < _breakpoints.getSize(); i++) {
 		if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), scriptFilename) == 0) {
@@ -578,7 +639,9 @@ bool ScEngine::removeBreakpoint(const char *scriptFilename, int line) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::refreshScriptBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		refreshScriptBreakpoints(_scripts[i]);
@@ -588,9 +651,13 @@ bool ScEngine::refreshScriptBreakpoints() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::refreshScriptBreakpoints(ScScript *script) {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
-	if (!script || !script->_filename) return STATUS_FAILED;
+	if (!script || !script->_filename) {
+		return STATUS_FAILED;
+	}
 
 	for (int i = 0; i < _breakpoints.getSize(); i++) {
 		if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), script->_filename) == 0) {
@@ -598,14 +665,18 @@ bool ScEngine::refreshScriptBreakpoints(ScScript *script) {
 			return STATUS_OK;
 		}
 	}
-	if (script->_breakpoints.getSize() > 0) script->_breakpoints.removeAll();
+	if (script->_breakpoints.getSize() > 0) {
+		script->_breakpoints.removeAll();
+	}
 
 	return STATUS_OK;
 }
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::saveBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
 
 	char text[512];
@@ -628,7 +699,9 @@ bool ScEngine::saveBreakpoints() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::loadBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) return STATUS_OK;
+	if (!_gameRef->getDebugMgr()->_enabled) {
+		return STATUS_OK;
+	}
 
 	char key[100];
 
@@ -641,7 +714,9 @@ bool ScEngine::loadBreakpoints() {
 		char *path = BaseUtils::strEntry(0, breakpoint.c_str(), ':');
 		char *line = BaseUtils::strEntry(1, breakpoint.c_str(), ':');
 
-		if (path != NULL && line != NULL) addBreakpoint(path, atoi(line));
+		if (path != NULL && line != NULL) {
+			addBreakpoint(path, atoi(line));
+		}
 		delete[] path;
 		delete[] line;
 		path = NULL;
@@ -654,7 +729,9 @@ bool ScEngine::loadBreakpoints() {
 
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::addScriptTime(const char *filename, uint32 time) {
-	if (!_isProfiling) return;
+	if (!_isProfiling) {
+		return;
+	}
 
 	AnsiString fileName = filename;
 	fileName.toLowercase();
@@ -664,7 +741,9 @@ void ScEngine::addScriptTime(const char *filename, uint32 time) {
 
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::enableProfiling() {
-	if (_isProfiling) return;
+	if (_isProfiling) {
+		return;
+	}
 
 	// destroy old data, if any
 	_scriptTimes.clear();
@@ -676,7 +755,9 @@ void ScEngine::enableProfiling() {
 
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::disableProfiling() {
-	if (!_isProfiling) return;
+	if (!_isProfiling) {
+		return;
+	}
 
 	dumpStats();
 	_isProfiling = false;
-- 
cgit v1.2.3


From 4eda234611bd77f053defe9e61d592b308270eaa Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Thu, 26 Jul 2012 19:41:18 +0200
Subject: WINTERMUTE: Replace BaseArray with a templated subclass of
 Common::Array.

This needs additional cleanup, but compiles and runs at this point.
---
 engines/wintermute/base/scriptables/script_engine.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 356617094d..e1aed7ed82 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -97,7 +97,7 @@ ScEngine::~ScEngine() {
 		delete _breakpoints[i];
 		_breakpoints[i] = NULL;
 	}
-	_breakpoints.removeAll();
+	_breakpoints.clear();
 }
 
 
@@ -108,11 +108,11 @@ bool ScEngine::cleanup() {
 			_scripts[i]->_owner->removeScript(_scripts[i]);
 		}
 		delete _scripts[i];
-		_scripts.removeAt(i);
+		_scripts.remove_at(i);
 		i--;
 	}
 
-	_scripts.removeAll();
+	_scripts.clear();
 
 	delete _globals;
 	_globals = NULL;
@@ -404,7 +404,7 @@ bool ScEngine::removeFinishedScripts() {
 			}
 			_gameRef->getDebugMgr()->onScriptShutdown(_scripts[i]);
 			delete _scripts[i];
-			_scripts.removeAt(i);
+			_scripts.remove_at(i);
 			i--;
 		}
 	}
@@ -511,7 +511,7 @@ void ScEngine::editorCleanup() {
 	for (int i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
 			delete _scripts[i];
-			_scripts.removeAt(i);
+			_scripts.remove_at(i);
 			i--;
 		}
 	}
@@ -620,10 +620,10 @@ bool ScEngine::removeBreakpoint(const char *scriptFilename, int line) {
 		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) {
-					_breakpoints[i]->_lines.removeAt(j);
+					_breakpoints[i]->_lines.remove_at(j);
 					if (_breakpoints[i]->_lines.getSize() == 0) {
 						delete _breakpoints[i];
-						_breakpoints.removeAt(i);
+						_breakpoints.remove_at(i);
 					}
 					// refresh changes
 					refreshScriptBreakpoints();
@@ -666,7 +666,7 @@ bool ScEngine::refreshScriptBreakpoints(ScScript *script) {
 		}
 	}
 	if (script->_breakpoints.getSize() > 0) {
-		script->_breakpoints.removeAll();
+		script->_breakpoints.clear();
 	}
 
 	return STATUS_OK;
-- 
cgit v1.2.3


From 3a49f2bad407787ef65d04c5f9ae423485629b41 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Thu, 26 Jul 2012 22:20:55 +0200
Subject: WINTERMUTE: More variable/function renaming VarName->varName

---
 engines/wintermute/base/scriptables/script_engine.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index e1aed7ed82..bc8d54ef58 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -227,13 +227,13 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
 	if (cachedScript) {
 		int index = 0;
-		uint32 MinTime = g_system->getMillis();
+		uint32 minTime = g_system->getMillis();
 		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
 			if (_cachedScripts[i] == NULL) {
 				index = i;
 				break;
-			} else if (_cachedScripts[i]->_timestamp <= MinTime) {
-				MinTime = _cachedScripts[i]->_timestamp;
+			} else if (_cachedScripts[i]->_timestamp <= minTime) {
+				minTime = _cachedScripts[i]->_timestamp;
 				index = i;
 			}
 		}
@@ -338,13 +338,13 @@ bool ScEngine::tick() {
 
 		// time sliced script
 		if (_scripts[i]->_timeSlice > 0) {
-			uint32 StartTime = g_system->getMillis();
-			while (_scripts[i]->_state == SCRIPT_RUNNING && g_system->getMillis() - StartTime < _scripts[i]->_timeSlice) {
+			uint32 startTime = g_system->getMillis();
+			while (_scripts[i]->_state == SCRIPT_RUNNING && g_system->getMillis() - startTime < _scripts[i]->_timeSlice) {
 				_currentScript = _scripts[i];
 				_scripts[i]->executeInstruction();
 			}
 			if (_isProfiling && _scripts[i]->_filename) {
-				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - StartTime);
+				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
 			}
 		}
 
@@ -473,8 +473,8 @@ bool ScEngine::resetObject(BaseObject *Object) {
 				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
+			bool isThread = _scripts[i]->_methodThread || _scripts[i]->_thread;
+			_scripts[i]->finish(!isThread); // 1.9b1 - top-level script kills its threads as well
 		}
 	}
 	return STATUS_OK;
@@ -707,7 +707,7 @@ bool ScEngine::loadBreakpoints() {
 
 	int count = _gameRef->_registry->readInt("Debug", "NumBreakpoints", 0);
 	for (int i = 1; i <= count; i++) {
-		/*  uint32 BufSize = 512; */
+		/*  uint32 bufSize = 512; */
 		sprintf(key, "Breakpoint%d", i);
 		AnsiString breakpoint = _gameRef->_registry->readString("Debug", key, "");
 
-- 
cgit v1.2.3


From 8ed71a99f6aaee27a3187cb47fe0c3b30acf88a0 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Fri, 27 Jul 2012 19:37:00 +0200
Subject: WINTERMUTE: Constructor(args): SuperClass(args) -> Constructor(args)
 : SuperClass(args)

---
 engines/wintermute/base/scriptables/script_engine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index bc8d54ef58..01f647c110 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -44,7 +44,7 @@ IMPLEMENT_PERSISTENT(ScEngine, true)
 
 #define COMPILER_DLL "dcscomp.dll"
 //////////////////////////////////////////////////////////////////////////
-ScEngine::ScEngine(BaseGame *inGame): BaseClass(inGame) {
+ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
 	_gameRef->LOG(0, "Initializing scripting engine...");
 
 	if (_compilerAvailable) {
-- 
cgit v1.2.3


From 9b5cf8f1bafd5aa0dba9194a8f04e58724652891 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sun, 29 Jul 2012 02:30:26 +0200
Subject: WINTERMUTE: Introduce a Singleton-class for holding
 registry/filemanager.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 01f647c110..9e11a7c5b4 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -33,6 +33,7 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script_ext_math.h"
 #include "engines/wintermute/base/base_registry.h"
+#include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/sound/base_sound.h"
 #include "engines/wintermute/base/base_file_manager.h"
@@ -128,7 +129,7 @@ bool ScEngine::cleanup() {
 //////////////////////////////////////////////////////////////////////////
 byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
 	BaseGame *gameRef = (BaseGame *)data;
-	return gameRef->_fileManager->readWholeFile(filename, size);
+	return BaseFileManager::getEngineInstance()->readWholeFile(filename, size);
 }
 
 
@@ -200,7 +201,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 	uint32 size;
 
-	byte *buffer = _gameRef->_fileManager->readWholeFile(filename, &size);
+	byte *buffer = BaseEngine::getInstance()->getFileManager()->readWholeFile(filename, &size);
 	if (!buffer) {
 		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
 		return NULL;
@@ -689,10 +690,10 @@ bool ScEngine::saveBreakpoints() {
 			sprintf(key, "Breakpoint%d", count);
 			sprintf(text, "%s:%d", _breakpoints[i]->_filename.c_str(), _breakpoints[i]->_lines[j]);
 
-			_gameRef->_registry->writeString("Debug", key, text);
+			BaseEngine::getInstance()->getRegistry()->writeString("Debug", key, text);
 		}
 	}
-	_gameRef->_registry->writeInt("Debug", "NumBreakpoints", count);
+	BaseEngine::getInstance()->getRegistry()->writeInt("Debug", "NumBreakpoints", count);
 
 	return STATUS_OK;
 }
@@ -705,11 +706,11 @@ bool ScEngine::loadBreakpoints() {
 
 	char key[100];
 
-	int count = _gameRef->_registry->readInt("Debug", "NumBreakpoints", 0);
+	int count = BaseEngine::getInstance()->getRegistry()->readInt("Debug", "NumBreakpoints", 0);
 	for (int i = 1; i <= count; i++) {
 		/*  uint32 bufSize = 512; */
 		sprintf(key, "Breakpoint%d", i);
-		AnsiString breakpoint = _gameRef->_registry->readString("Debug", key, "");
+		AnsiString breakpoint = BaseEngine::getInstance()->getRegistry()->readString("Debug", key, "");
 
 		char *path = BaseUtils::strEntry(0, breakpoint.c_str(), ':');
 		char *line = BaseUtils::strEntry(1, breakpoint.c_str(), ':');
-- 
cgit v1.2.3


From 482a5fb467e6694fb54c75f718563992657edf97 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sun, 29 Jul 2012 02:59:14 +0200
Subject: WINTERMUTE: Make the BaseEngine-singleton use Common::Singleton as
 super-class

---
 engines/wintermute/base/scriptables/script_engine.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 9e11a7c5b4..96250dbb90 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -128,7 +128,6 @@ bool ScEngine::cleanup() {
 
 //////////////////////////////////////////////////////////////////////////
 byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
-	BaseGame *gameRef = (BaseGame *)data;
 	return BaseFileManager::getEngineInstance()->readWholeFile(filename, size);
 }
 
@@ -201,7 +200,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 	uint32 size;
 
-	byte *buffer = BaseEngine::getInstance()->getFileManager()->readWholeFile(filename, &size);
+	byte *buffer = BaseEngine::instance().getFileManager()->readWholeFile(filename, &size);
 	if (!buffer) {
 		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
 		return NULL;
@@ -690,10 +689,10 @@ bool ScEngine::saveBreakpoints() {
 			sprintf(key, "Breakpoint%d", count);
 			sprintf(text, "%s:%d", _breakpoints[i]->_filename.c_str(), _breakpoints[i]->_lines[j]);
 
-			BaseEngine::getInstance()->getRegistry()->writeString("Debug", key, text);
+			BaseEngine::instance().getRegistry()->writeString("Debug", key, text);
 		}
 	}
-	BaseEngine::getInstance()->getRegistry()->writeInt("Debug", "NumBreakpoints", count);
+	BaseEngine::instance().getRegistry()->writeInt("Debug", "NumBreakpoints", count);
 
 	return STATUS_OK;
 }
@@ -706,11 +705,11 @@ bool ScEngine::loadBreakpoints() {
 
 	char key[100];
 
-	int count = BaseEngine::getInstance()->getRegistry()->readInt("Debug", "NumBreakpoints", 0);
+	int count = BaseEngine::instance().getRegistry()->readInt("Debug", "NumBreakpoints", 0);
 	for (int i = 1; i <= count; i++) {
 		/*  uint32 bufSize = 512; */
 		sprintf(key, "Breakpoint%d", i);
-		AnsiString breakpoint = BaseEngine::getInstance()->getRegistry()->readString("Debug", key, "");
+		AnsiString breakpoint = BaseEngine::instance().getRegistry()->readString("Debug", key, "");
 
 		char *path = BaseUtils::strEntry(0, breakpoint.c_str(), ':');
 		char *line = BaseUtils::strEntry(1, breakpoint.c_str(), ':');
-- 
cgit v1.2.3


From aa3467ddaa4b1df72398a1545c9d8b1c89dad6ad Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sun, 29 Jul 2012 15:30:44 +0200
Subject: WINTERMUTE: Remove the debugger.

---
 .../wintermute/base/scriptables/script_engine.cpp  | 181 +--------------------
 1 file changed, 1 insertion(+), 180 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 96250dbb90..06f584c9bb 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -88,17 +88,10 @@ ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
 //////////////////////////////////////////////////////////////////////////
 ScEngine::~ScEngine() {
 	_gameRef->LOG(0, "Shutting down scripting engine");
-	saveBreakpoints();
 
 	disableProfiling();
 
 	cleanup();
-
-	for (int i = 0; i < _breakpoints.getSize(); i++) {
-		delete _breakpoints[i];
-		_breakpoints[i] = NULL;
-	}
-	_breakpoints.clear();
 }
 
 
@@ -174,7 +167,6 @@ ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
 		script->_globals->setProp("this", &val);
 
 		_scripts.add(script);
-		_gameRef->getDebugMgr()->onScriptInit(script);
 
 		return script;
 	}
@@ -402,7 +394,7 @@ bool ScEngine::removeFinishedScripts() {
 			if (!_scripts[i]->_thread && _scripts[i]->_owner) {
 				_scripts[i]->_owner->removeScript(_scripts[i]);
 			}
-			_gameRef->getDebugMgr()->onScriptShutdown(_scripts[i]);
+
 			delete _scripts[i];
 			_scripts.remove_at(i);
 			i--;
@@ -556,177 +548,6 @@ bool ScEngine::clearGlobals(bool includingNatives) {
 	return STATUS_OK;
 }
 
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::dbgSendScripts(IWmeDebugClient *client) {
-	// send global variables
-	_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);
-	}
-
-	// and threads later
-	for (int i = 0; i < _scripts.getSize(); i++) {
-		if (_scripts[i]->_thread || _scripts[i]->_methodThread) {
-			_scripts[i]->dbgSendScript(client);
-		}
-	}
-
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::addBreakpoint(const char *scriptFilename, int line) {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-	CScBreakpoint *bp = NULL;
-	for (int i = 0; i < _breakpoints.getSize(); 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);
-	}
-
-	for (int i = 0; i < bp->_lines.getSize(); i++) {
-		if (bp->_lines[i] == line) {
-			return STATUS_OK;
-		}
-	}
-	bp->_lines.add(line);
-
-	// refresh changes
-	refreshScriptBreakpoints();
-
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::removeBreakpoint(const char *scriptFilename, int line) {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-	for (int i = 0; i < _breakpoints.getSize(); i++) {
-		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) {
-					_breakpoints[i]->_lines.remove_at(j);
-					if (_breakpoints[i]->_lines.getSize() == 0) {
-						delete _breakpoints[i];
-						_breakpoints.remove_at(i);
-					}
-					// refresh changes
-					refreshScriptBreakpoints();
-
-					return STATUS_OK;
-				}
-			}
-			break;
-		}
-	}
-	return STATUS_FAILED;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::refreshScriptBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-	for (int i = 0; i < _scripts.getSize(); i++) {
-		refreshScriptBreakpoints(_scripts[i]);
-	}
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::refreshScriptBreakpoints(ScScript *script) {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-	if (!script || !script->_filename) {
-		return STATUS_FAILED;
-	}
-
-	for (int i = 0; i < _breakpoints.getSize(); i++) {
-		if (scumm_stricmp(_breakpoints[i]->_filename.c_str(), script->_filename) == 0) {
-			script->_breakpoints.copy(_breakpoints[i]->_lines);
-			return STATUS_OK;
-		}
-	}
-	if (script->_breakpoints.getSize() > 0) {
-		script->_breakpoints.clear();
-	}
-
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::saveBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-
-	char text[512];
-	char key[100];
-
-	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]);
-
-			BaseEngine::instance().getRegistry()->writeString("Debug", key, text);
-		}
-	}
-	BaseEngine::instance().getRegistry()->writeInt("Debug", "NumBreakpoints", count);
-
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::loadBreakpoints() {
-	if (!_gameRef->getDebugMgr()->_enabled) {
-		return STATUS_OK;
-	}
-
-	char key[100];
-
-	int count = BaseEngine::instance().getRegistry()->readInt("Debug", "NumBreakpoints", 0);
-	for (int i = 1; i <= count; i++) {
-		/*  uint32 bufSize = 512; */
-		sprintf(key, "Breakpoint%d", i);
-		AnsiString breakpoint = BaseEngine::instance().getRegistry()->readString("Debug", key, "");
-
-		char *path = BaseUtils::strEntry(0, breakpoint.c_str(), ':');
-		char *line = BaseUtils::strEntry(1, breakpoint.c_str(), ':');
-
-		if (path != NULL && line != NULL) {
-			addBreakpoint(path, atoi(line));
-		}
-		delete[] path;
-		delete[] line;
-		path = NULL;
-		line = NULL;
-	}
-
-	return STATUS_OK;
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::addScriptTime(const char *filename, uint32 time) {
 	if (!_isProfiling) {
-- 
cgit v1.2.3


From 2e7d21fc525a5b0451274d3844e3d6a1de1f6cb2 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sun, 29 Jul 2012 17:53:44 +0200
Subject: WINTERMUTE: Replace BaseRegistry with ConfMan

---
 engines/wintermute/base/scriptables/script_engine.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 06f584c9bb..e5d965a4b1 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -32,7 +32,6 @@
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script_ext_math.h"
-#include "engines/wintermute/base/base_registry.h"
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/sound/base_sound.h"
-- 
cgit v1.2.3


From 20e2ec4ff4d869ba54edf5b930d84340245292b6 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Sun, 29 Jul 2012 18:00:15 +0200
Subject: WINTERMUTE: Remove unused functions from StringUtil::

---
 engines/wintermute/base/scriptables/script_engine.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index e5d965a4b1..a1f246c4bc 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -27,7 +27,6 @@
  */
 
 #include "engines/wintermute/base/scriptables/script_engine.h"
-#include "engines/wintermute/utils/string_util.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
-- 
cgit v1.2.3


From fed19cb66ae5b56dd7dc81b90edd5a0d15986678 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Mon, 13 Aug 2012 03:42:30 +0200
Subject: WINTERMUTE: WinterMute -> Wintermute

---
 engines/wintermute/base/scriptables/script_engine.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index a1f246c4bc..8765fb9864 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -37,7 +37,7 @@
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/utils/utils.h"
 
-namespace WinterMute {
+namespace Wintermute {
 
 IMPLEMENT_PERSISTENT(ScEngine, true)
 
@@ -608,4 +608,4 @@ void ScEngine::dumpStats() {
 	    }*/
 }
 
-} // end of namespace WinterMute
+} // end of namespace Wintermute
-- 
cgit v1.2.3


From 10ca0f136d120677d776981fc58aba548181c033 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Wed, 15 Aug 2012 02:35:11 +0200
Subject: WINTERMUTE: Clear out some commented-out code.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 8765fb9864..575e24a3a3 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -312,7 +312,6 @@ bool ScEngine::tick() {
 			break;
 		}
 		default:
-			//warning("ScEngine::Tick - Unhandled enum");
 			break;
 		} // switch
 	} // for each script
-- 
cgit v1.2.3


From 2fd38f47e04430b8684502e625f87a04dd968def Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Fri, 31 Aug 2012 18:25:24 +0200
Subject: WINTERMUTE: Replace col_templ's getSize with Common::Array::size()

---
 .../wintermute/base/scriptables/script_engine.cpp  | 28 +++++++++++-----------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 575e24a3a3..d518be579f 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -95,7 +95,7 @@ ScEngine::~ScEngine() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::cleanup() {
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (!_scripts[i]->_thread && _scripts[i]->_owner) {
 			_scripts[i]->_owner->removeScript(_scripts[i]);
 		}
@@ -248,19 +248,19 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::tick() {
-	if (_scripts.getSize() == 0) {
+	if (_scripts.size() == 0) {
 		return STATUS_OK;
 	}
 
 
 	// resolve waiting scripts
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 
 		switch (_scripts[i]->_state) {
 		case SCRIPT_WAITING: {
 			/*
 			bool obj_found=false;
-			for(int j=0; j<_gameRef->_regObjects.getSize(); j++)
+			for(int j=0; j<_gameRef->_regObjects.size(); j++)
 			{
 			    if (_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
 			    {
@@ -318,7 +318,7 @@ bool ScEngine::tick() {
 
 
 	// execute scripts
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 
 		// skip paused scripts
 		if (_scripts[i]->_state == SCRIPT_PAUSED) {
@@ -365,7 +365,7 @@ bool ScEngine::tick() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::tickUnbreakable() {
 	// execute unbreakable scripts
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (!_scripts[i]->_unbreakable) {
 			continue;
 		}
@@ -386,7 +386,7 @@ bool ScEngine::tickUnbreakable() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::removeFinishedScripts() {
 	// remove finished scripts
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
 			if (!_scripts[i]->_thread && _scripts[i]->_owner) {
 				_scripts[i]->_owner->removeScript(_scripts[i]);
@@ -405,7 +405,7 @@ bool ScEngine::removeFinishedScripts() {
 int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 	int numRunning = 0, numWaiting = 0, numPersistent = 0, numTotal = 0;
 
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i]->_state == SCRIPT_FINISHED) {
 			continue;
 		}
@@ -456,7 +456,7 @@ bool ScEngine::emptyScriptCache() {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::resetObject(BaseObject *Object) {
 	// terminate all scripts waiting for this object
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
 			if (!_gameRef->_compatKillMethodThreads) {
 				resetScript(_scripts[i]);
@@ -472,7 +472,7 @@ bool ScEngine::resetObject(BaseObject *Object) {
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::resetScript(ScScript *script) {
 	// terminate all scripts waiting for this script
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i]->_state == SCRIPT_WAITING_SCRIPT && _scripts[i]->_waitScript == script) {
 			_scripts[i]->finish();
 		}
@@ -497,7 +497,7 @@ bool ScEngine::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void ScEngine::editorCleanup() {
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
 			delete _scripts[i];
 			_scripts.remove_at(i);
@@ -509,7 +509,7 @@ void ScEngine::editorCleanup() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::pauseAll() {
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i] != _currentScript) {
 			_scripts[i]->pause();
 		}
@@ -521,7 +521,7 @@ bool ScEngine::pauseAll() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::resumeAll() {
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		_scripts[i]->resume();
 	}
 
@@ -531,7 +531,7 @@ bool ScEngine::resumeAll() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScEngine::isValidScript(ScScript *script) {
-	for (int i = 0; i < _scripts.getSize(); i++) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (_scripts[i] == script) {
 			return true;
 		}
-- 
cgit v1.2.3


From 158a2060868eceff254460a89b67d78dc650bc94 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Fri, 31 Aug 2012 19:42:53 +0200
Subject: WINTERMUTE: Use ++it instead of it++

---
 engines/wintermute/base/scriptables/script_engine.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index d518be579f..02f6080958 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -591,7 +591,7 @@ void ScEngine::dumpStats() {
 	    TimeVector times;
 
 	    ScriptTimes::iterator it;
-	    for (it = _scriptTimes.begin(); it != _scriptTimes.end(); it++) {
+	    for (it = _scriptTimes.begin(); it != _scriptTimes.end(); ++it) {
 	        times.push_back(std::pair<uint32, std::string> (it->_value, it->_key));
 	    }
 	    std::sort(times.begin(), times.end());
@@ -602,7 +602,7 @@ void ScEngine::dumpStats() {
 	    _gameRef->LOG(0, "***** Script profiling information: *****");
 	    _gameRef->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
 
-	    for (tit = times.rbegin(); tit != times.rend(); tit++) {
+	    for (tit = times.rbegin(); tit != times.rend(); ++tit) {
 	        _gameRef->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
 	    }*/
 }
-- 
cgit v1.2.3


From b4090ead4d4334e08725323ff72fd355c93b63d5 Mon Sep 17 00:00:00 2001
From: Willem Jan Palenstijn
Date: Tue, 4 Sep 2012 22:17:23 +0200
Subject: WINTERMUTE: Convert CRLF to LF

---
 .../wintermute/base/scriptables/script_engine.cpp  | 1220 ++++++++++----------
 1 file changed, 610 insertions(+), 610 deletions(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 02f6080958..20e2ccadd1 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -1,610 +1,610 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- */
-
-/*
- * This file is based on WME Lite.
- * http://dead-code.org/redir.php?target=wmelite
- * Copyright (c) 2011 Jan Nedoma
- */
-
-#include "engines/wintermute/base/scriptables/script_engine.h"
-#include "engines/wintermute/base/scriptables/script_value.h"
-#include "engines/wintermute/base/scriptables/script.h"
-#include "engines/wintermute/base/scriptables/script_stack.h"
-#include "engines/wintermute/base/scriptables/script_ext_math.h"
-#include "engines/wintermute/base/base_engine.h"
-#include "engines/wintermute/base/base_game.h"
-#include "engines/wintermute/base/sound/base_sound.h"
-#include "engines/wintermute/base/base_file_manager.h"
-#include "engines/wintermute/utils/utils.h"
-
-namespace Wintermute {
-
-IMPLEMENT_PERSISTENT(ScEngine, true)
-
-#define COMPILER_DLL "dcscomp.dll"
-//////////////////////////////////////////////////////////////////////////
-ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
-	_gameRef->LOG(0, "Initializing scripting engine...");
-
-	if (_compilerAvailable) {
-		_gameRef->LOG(0, "  Script compiler bound successfuly");
-	} else {
-		_gameRef->LOG(0, "  Script compiler is NOT available");
-	}
-
-	_globals = new ScValue(_gameRef);
-
-
-	// register 'Game' as global variable
-	if (!_globals->propExists("Game")) {
-		ScValue val(_gameRef);
-		val.setNative(_gameRef,  true);
-		_globals->setProp("Game", &val);
-	}
-
-	// register 'Math' as global variable
-	if (!_globals->propExists("Math")) {
-		ScValue val(_gameRef);
-		val.setNative(_gameRef->_mathClass, true);
-		_globals->setProp("Math", &val);
-	}
-
-	// prepare script cache
-	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
-		_cachedScripts[i] = NULL;
-	}
-
-	_currentScript = NULL;
-
-	_isProfiling = false;
-	_profilingStartTime = 0;
-
-	//EnableProfiling();
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-ScEngine::~ScEngine() {
-	_gameRef->LOG(0, "Shutting down scripting engine");
-
-	disableProfiling();
-
-	cleanup();
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::cleanup() {
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (!_scripts[i]->_thread && _scripts[i]->_owner) {
-			_scripts[i]->_owner->removeScript(_scripts[i]);
-		}
-		delete _scripts[i];
-		_scripts.remove_at(i);
-		i--;
-	}
-
-	_scripts.clear();
-
-	delete _globals;
-	_globals = NULL;
-
-	emptyScriptCache();
-
-	_currentScript = NULL; // ref only
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
-	return BaseFileManager::getEngineInstance()->readWholeFile(filename, size);
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::closeFile(void *data, byte *buffer) {
-	delete[] buffer;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::parseElement(void *data, int line, int type, void *elementData) {
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
-	byte *compBuffer;
-	uint32 compSize;
-
-	// get script from cache
-	compBuffer = getCompiledScript(filename, &compSize);
-	if (!compBuffer) {
-		return NULL;
-	}
-
-	// add new script
-	ScScript *script = new ScScript(_gameRef, this);
-	bool ret = script->create(filename, compBuffer, compSize, owner);
-	if (DID_FAIL(ret)) {
-		_gameRef->LOG(ret, "Error running script '%s'...", filename);
-		delete script;
-		return NULL;
-	} else {
-		// publish the "self" pseudo-variable
-		ScValue val(_gameRef);
-		if (owner) {
-			val.setNative(owner, true);
-		} else {
-			val.setNULL();
-		}
-
-		script->_globals->setProp("self", &val);
-		script->_globals->setProp("this", &val);
-
-		_scripts.add(script);
-
-		return script;
-	}
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
-	// is script in cache?
-	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 = g_system->getMillis();
-				*outSize = _cachedScripts[i]->_size;
-				return _cachedScripts[i]->_buffer;
-			}
-		}
-	}
-
-	// nope, load it
-	byte *compBuffer;
-	uint32 compSize;
-
-	uint32 size;
-
-	byte *buffer = BaseEngine::instance().getFileManager()->readWholeFile(filename, &size);
-	if (!buffer) {
-		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
-		return NULL;
-	}
-
-	// needs to be compiled?
-	if (FROM_LE_32(*(uint32 *)buffer) == SCRIPT_MAGIC) {
-		compBuffer = buffer;
-		compSize = size;
-	} else {
-		if (!_compilerAvailable) {
-			_gameRef->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
-			delete[] buffer;
-			return NULL;
-		}
-		// This code will never be called, since _compilerAvailable is const false.
-		// It's only here in the event someone would want to reinclude the compiler.
-		error("Script needs compilation, ScummVM does not contain a WME compiler");
-	}
-
-	byte *ret = NULL;
-
-	// add script to cache
-	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
-	if (cachedScript) {
-		int index = 0;
-		uint32 minTime = g_system->getMillis();
-		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
-			if (_cachedScripts[i] == NULL) {
-				index = i;
-				break;
-			} else if (_cachedScripts[i]->_timestamp <= minTime) {
-				minTime = _cachedScripts[i]->_timestamp;
-				index = i;
-			}
-		}
-
-		if (_cachedScripts[index] != NULL) {
-			delete _cachedScripts[index];
-		}
-		_cachedScripts[index] = cachedScript;
-
-		ret = cachedScript->_buffer;
-		*outSize = cachedScript->_size;
-	}
-
-
-	// cleanup
-	delete[] buffer;
-
-	return ret;
-}
-
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::tick() {
-	if (_scripts.size() == 0) {
-		return STATUS_OK;
-	}
-
-
-	// resolve waiting scripts
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-
-		switch (_scripts[i]->_state) {
-		case SCRIPT_WAITING: {
-			/*
-			bool obj_found=false;
-			for(int j=0; j<_gameRef->_regObjects.size(); j++)
-			{
-			    if (_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
-			    {
-			        if (_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
-			        obj_found = true;
-			        break;
-			    }
-			}
-			if (!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
-			*/
-			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
-				if (_scripts[i]->_waitObject->isReady()) {
-					_scripts[i]->run();
-				}
-			} else {
-				_scripts[i]->finish();
-			}
-			break;
-		}
-
-		case SCRIPT_SLEEPING: {
-			if (_scripts[i]->_waitFrozen) {
-				if (_scripts[i]->_waitTime <= g_system->getMillis()) {
-					_scripts[i]->run();
-				}
-			} else {
-				if (_scripts[i]->_waitTime <= _gameRef->_timer) {
-					_scripts[i]->run();
-				}
-			}
-			break;
-		}
-
-		case SCRIPT_WAITING_SCRIPT: {
-			if (!isValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
-				// fake return value
-				_scripts[i]->_stack->pushNULL();
-				_scripts[i]->_waitScript = NULL;
-				_scripts[i]->run();
-			} else {
-				if (_scripts[i]->_waitScript->_state == SCRIPT_THREAD_FINISHED) {
-					// copy return value
-					_scripts[i]->_stack->push(_scripts[i]->_waitScript->_stack->pop());
-					_scripts[i]->run();
-					_scripts[i]->_waitScript->finish();
-					_scripts[i]->_waitScript = NULL;
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		} // switch
-	} // for each script
-
-
-	// execute scripts
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-
-		// skip paused scripts
-		if (_scripts[i]->_state == SCRIPT_PAUSED) {
-			continue;
-		}
-
-		// time sliced script
-		if (_scripts[i]->_timeSlice > 0) {
-			uint32 startTime = g_system->getMillis();
-			while (_scripts[i]->_state == SCRIPT_RUNNING && g_system->getMillis() - startTime < _scripts[i]->_timeSlice) {
-				_currentScript = _scripts[i];
-				_scripts[i]->executeInstruction();
-			}
-			if (_isProfiling && _scripts[i]->_filename) {
-				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
-			}
-		}
-
-		// normal script
-		else {
-			uint32 startTime = 0;
-			bool isProfiling = _isProfiling;
-			if (isProfiling) {
-				startTime = g_system->getMillis();
-			}
-
-			while (_scripts[i]->_state == SCRIPT_RUNNING) {
-				_currentScript = _scripts[i];
-				_scripts[i]->executeInstruction();
-			}
-			if (isProfiling && _scripts[i]->_filename) {
-				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
-			}
-		}
-		_currentScript = NULL;
-	}
-
-	removeFinishedScripts();
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::tickUnbreakable() {
-	// execute unbreakable scripts
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (!_scripts[i]->_unbreakable) {
-			continue;
-		}
-
-		while (_scripts[i]->_state == SCRIPT_RUNNING) {
-			_currentScript = _scripts[i];
-			_scripts[i]->executeInstruction();
-		}
-		_scripts[i]->finish();
-		_currentScript = NULL;
-	}
-	removeFinishedScripts();
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::removeFinishedScripts() {
-	// remove finished scripts
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
-			if (!_scripts[i]->_thread && _scripts[i]->_owner) {
-				_scripts[i]->_owner->removeScript(_scripts[i]);
-			}
-
-			delete _scripts[i];
-			_scripts.remove_at(i);
-			i--;
-		}
-	}
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
-	int numRunning = 0, numWaiting = 0, numPersistent = 0, numTotal = 0;
-
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i]->_state == SCRIPT_FINISHED) {
-			continue;
-		}
-		switch (_scripts[i]->_state) {
-		case SCRIPT_RUNNING:
-		case SCRIPT_SLEEPING:
-		case SCRIPT_PAUSED:
-			numRunning++;
-			break;
-		case SCRIPT_WAITING:
-			numWaiting++;
-			break;
-		case SCRIPT_PERSISTENT:
-			numPersistent++;
-			break;
-		default:
-			warning("ScEngine::GetNumScripts - unhandled enum");
-			break;
-		}
-		numTotal++;
-	}
-	if (running) {
-		*running = numRunning;
-	}
-	if (waiting) {
-		*waiting = numWaiting;
-	}
-	if (persistent) {
-		*persistent = numPersistent;
-	}
-
-	return numTotal;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::emptyScriptCache() {
-	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
-		if (_cachedScripts[i]) {
-			delete _cachedScripts[i];
-			_cachedScripts[i] = NULL;
-		}
-	}
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::resetObject(BaseObject *Object) {
-	// terminate all scripts waiting for this object
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
-			if (!_gameRef->_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
-		}
-	}
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::resetScript(ScScript *script) {
-	// terminate all scripts waiting for this script
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i]->_state == SCRIPT_WAITING_SCRIPT && _scripts[i]->_waitScript == script) {
-			_scripts[i]->finish();
-		}
-	}
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::persist(BasePersistenceManager *persistMgr) {
-	if (!persistMgr->getIsSaving()) {
-		cleanup();
-	}
-
-	persistMgr->transfer(TMEMBER(_gameRef));
-	persistMgr->transfer(TMEMBER(_currentScript));
-	persistMgr->transfer(TMEMBER(_globals));
-	_scripts.persist(persistMgr);
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::editorCleanup() {
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
-			delete _scripts[i];
-			_scripts.remove_at(i);
-			i--;
-		}
-	}
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::pauseAll() {
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i] != _currentScript) {
-			_scripts[i]->pause();
-		}
-	}
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::resumeAll() {
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		_scripts[i]->resume();
-	}
-
-	return STATUS_OK;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::isValidScript(ScScript *script) {
-	for (uint32 i = 0; i < _scripts.size(); i++) {
-		if (_scripts[i] == script) {
-			return true;
-		}
-	}
-	return false;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool ScEngine::clearGlobals(bool includingNatives) {
-	_globals->CleanProps(includingNatives);
-	return STATUS_OK;
-}
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::addScriptTime(const char *filename, uint32 time) {
-	if (!_isProfiling) {
-		return;
-	}
-
-	AnsiString fileName = filename;
-	fileName.toLowercase();
-	_scriptTimes[fileName] += time;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::enableProfiling() {
-	if (_isProfiling) {
-		return;
-	}
-
-	// destroy old data, if any
-	_scriptTimes.clear();
-
-	_profilingStartTime = g_system->getMillis();
-	_isProfiling = true;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::disableProfiling() {
-	if (!_isProfiling) {
-		return;
-	}
-
-	dumpStats();
-	_isProfiling = false;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-void ScEngine::dumpStats() {
-	error("DumpStats not ported to ScummVM yet");
-	/*  uint32 totalTime = g_system->getMillis() - _profilingStartTime;
-
-	    typedef std::vector <std::pair<uint32, std::string> > TimeVector;
-	    TimeVector times;
-
-	    ScriptTimes::iterator it;
-	    for (it = _scriptTimes.begin(); it != _scriptTimes.end(); ++it) {
-	        times.push_back(std::pair<uint32, std::string> (it->_value, it->_key));
-	    }
-	    std::sort(times.begin(), times.end());
-
-
-	    TimeVector::reverse_iterator tit;
-
-	    _gameRef->LOG(0, "***** Script profiling information: *****");
-	    _gameRef->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
-
-	    for (tit = times.rbegin(); tit != times.rend(); ++tit) {
-	        _gameRef->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
-	    }*/
-}
-
-} // end of namespace Wintermute
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "engines/wintermute/base/scriptables/script_engine.h"
+#include "engines/wintermute/base/scriptables/script_value.h"
+#include "engines/wintermute/base/scriptables/script.h"
+#include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/base/scriptables/script_ext_math.h"
+#include "engines/wintermute/base/base_engine.h"
+#include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/sound/base_sound.h"
+#include "engines/wintermute/base/base_file_manager.h"
+#include "engines/wintermute/utils/utils.h"
+
+namespace Wintermute {
+
+IMPLEMENT_PERSISTENT(ScEngine, true)
+
+#define COMPILER_DLL "dcscomp.dll"
+//////////////////////////////////////////////////////////////////////////
+ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
+	_gameRef->LOG(0, "Initializing scripting engine...");
+
+	if (_compilerAvailable) {
+		_gameRef->LOG(0, "  Script compiler bound successfuly");
+	} else {
+		_gameRef->LOG(0, "  Script compiler is NOT available");
+	}
+
+	_globals = new ScValue(_gameRef);
+
+
+	// register 'Game' as global variable
+	if (!_globals->propExists("Game")) {
+		ScValue val(_gameRef);
+		val.setNative(_gameRef,  true);
+		_globals->setProp("Game", &val);
+	}
+
+	// register 'Math' as global variable
+	if (!_globals->propExists("Math")) {
+		ScValue val(_gameRef);
+		val.setNative(_gameRef->_mathClass, true);
+		_globals->setProp("Math", &val);
+	}
+
+	// prepare script cache
+	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+		_cachedScripts[i] = NULL;
+	}
+
+	_currentScript = NULL;
+
+	_isProfiling = false;
+	_profilingStartTime = 0;
+
+	//EnableProfiling();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+ScEngine::~ScEngine() {
+	_gameRef->LOG(0, "Shutting down scripting engine");
+
+	disableProfiling();
+
+	cleanup();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::cleanup() {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (!_scripts[i]->_thread && _scripts[i]->_owner) {
+			_scripts[i]->_owner->removeScript(_scripts[i]);
+		}
+		delete _scripts[i];
+		_scripts.remove_at(i);
+		i--;
+	}
+
+	_scripts.clear();
+
+	delete _globals;
+	_globals = NULL;
+
+	emptyScriptCache();
+
+	_currentScript = NULL; // ref only
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+byte *ScEngine::loadFile(void *data, char *filename, uint32 *size) {
+	return BaseFileManager::getEngineInstance()->readWholeFile(filename, size);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::closeFile(void *data, byte *buffer) {
+	delete[] buffer;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::parseElement(void *data, int line, int type, void *elementData) {
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
+	byte *compBuffer;
+	uint32 compSize;
+
+	// get script from cache
+	compBuffer = getCompiledScript(filename, &compSize);
+	if (!compBuffer) {
+		return NULL;
+	}
+
+	// add new script
+	ScScript *script = new ScScript(_gameRef, this);
+	bool ret = script->create(filename, compBuffer, compSize, owner);
+	if (DID_FAIL(ret)) {
+		_gameRef->LOG(ret, "Error running script '%s'...", filename);
+		delete script;
+		return NULL;
+	} else {
+		// publish the "self" pseudo-variable
+		ScValue val(_gameRef);
+		if (owner) {
+			val.setNative(owner, true);
+		} else {
+			val.setNULL();
+		}
+
+		script->_globals->setProp("self", &val);
+		script->_globals->setProp("this", &val);
+
+		_scripts.add(script);
+
+		return script;
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ignoreCache) {
+	// is script in cache?
+	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 = g_system->getMillis();
+				*outSize = _cachedScripts[i]->_size;
+				return _cachedScripts[i]->_buffer;
+			}
+		}
+	}
+
+	// nope, load it
+	byte *compBuffer;
+	uint32 compSize;
+
+	uint32 size;
+
+	byte *buffer = BaseEngine::instance().getFileManager()->readWholeFile(filename, &size);
+	if (!buffer) {
+		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
+		return NULL;
+	}
+
+	// needs to be compiled?
+	if (FROM_LE_32(*(uint32 *)buffer) == SCRIPT_MAGIC) {
+		compBuffer = buffer;
+		compSize = size;
+	} else {
+		if (!_compilerAvailable) {
+			_gameRef->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
+			delete[] buffer;
+			return NULL;
+		}
+		// This code will never be called, since _compilerAvailable is const false.
+		// It's only here in the event someone would want to reinclude the compiler.
+		error("Script needs compilation, ScummVM does not contain a WME compiler");
+	}
+
+	byte *ret = NULL;
+
+	// add script to cache
+	CScCachedScript *cachedScript = new CScCachedScript(filename, compBuffer, compSize);
+	if (cachedScript) {
+		int index = 0;
+		uint32 minTime = g_system->getMillis();
+		for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+			if (_cachedScripts[i] == NULL) {
+				index = i;
+				break;
+			} else if (_cachedScripts[i]->_timestamp <= minTime) {
+				minTime = _cachedScripts[i]->_timestamp;
+				index = i;
+			}
+		}
+
+		if (_cachedScripts[index] != NULL) {
+			delete _cachedScripts[index];
+		}
+		_cachedScripts[index] = cachedScript;
+
+		ret = cachedScript->_buffer;
+		*outSize = cachedScript->_size;
+	}
+
+
+	// cleanup
+	delete[] buffer;
+
+	return ret;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::tick() {
+	if (_scripts.size() == 0) {
+		return STATUS_OK;
+	}
+
+
+	// resolve waiting scripts
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+
+		switch (_scripts[i]->_state) {
+		case SCRIPT_WAITING: {
+			/*
+			bool obj_found=false;
+			for(int j=0; j<_gameRef->_regObjects.size(); j++)
+			{
+			    if (_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
+			    {
+			        if (_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
+			        obj_found = true;
+			        break;
+			    }
+			}
+			if (!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
+			*/
+			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
+				if (_scripts[i]->_waitObject->isReady()) {
+					_scripts[i]->run();
+				}
+			} else {
+				_scripts[i]->finish();
+			}
+			break;
+		}
+
+		case SCRIPT_SLEEPING: {
+			if (_scripts[i]->_waitFrozen) {
+				if (_scripts[i]->_waitTime <= g_system->getMillis()) {
+					_scripts[i]->run();
+				}
+			} else {
+				if (_scripts[i]->_waitTime <= _gameRef->_timer) {
+					_scripts[i]->run();
+				}
+			}
+			break;
+		}
+
+		case SCRIPT_WAITING_SCRIPT: {
+			if (!isValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
+				// fake return value
+				_scripts[i]->_stack->pushNULL();
+				_scripts[i]->_waitScript = NULL;
+				_scripts[i]->run();
+			} else {
+				if (_scripts[i]->_waitScript->_state == SCRIPT_THREAD_FINISHED) {
+					// copy return value
+					_scripts[i]->_stack->push(_scripts[i]->_waitScript->_stack->pop());
+					_scripts[i]->run();
+					_scripts[i]->_waitScript->finish();
+					_scripts[i]->_waitScript = NULL;
+				}
+			}
+			break;
+		}
+		default:
+			break;
+		} // switch
+	} // for each script
+
+
+	// execute scripts
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+
+		// skip paused scripts
+		if (_scripts[i]->_state == SCRIPT_PAUSED) {
+			continue;
+		}
+
+		// time sliced script
+		if (_scripts[i]->_timeSlice > 0) {
+			uint32 startTime = g_system->getMillis();
+			while (_scripts[i]->_state == SCRIPT_RUNNING && g_system->getMillis() - startTime < _scripts[i]->_timeSlice) {
+				_currentScript = _scripts[i];
+				_scripts[i]->executeInstruction();
+			}
+			if (_isProfiling && _scripts[i]->_filename) {
+				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
+			}
+		}
+
+		// normal script
+		else {
+			uint32 startTime = 0;
+			bool isProfiling = _isProfiling;
+			if (isProfiling) {
+				startTime = g_system->getMillis();
+			}
+
+			while (_scripts[i]->_state == SCRIPT_RUNNING) {
+				_currentScript = _scripts[i];
+				_scripts[i]->executeInstruction();
+			}
+			if (isProfiling && _scripts[i]->_filename) {
+				addScriptTime(_scripts[i]->_filename, g_system->getMillis() - startTime);
+			}
+		}
+		_currentScript = NULL;
+	}
+
+	removeFinishedScripts();
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::tickUnbreakable() {
+	// execute unbreakable scripts
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (!_scripts[i]->_unbreakable) {
+			continue;
+		}
+
+		while (_scripts[i]->_state == SCRIPT_RUNNING) {
+			_currentScript = _scripts[i];
+			_scripts[i]->executeInstruction();
+		}
+		_scripts[i]->finish();
+		_currentScript = NULL;
+	}
+	removeFinishedScripts();
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::removeFinishedScripts() {
+	// remove finished scripts
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
+			if (!_scripts[i]->_thread && _scripts[i]->_owner) {
+				_scripts[i]->_owner->removeScript(_scripts[i]);
+			}
+
+			delete _scripts[i];
+			_scripts.remove_at(i);
+			i--;
+		}
+	}
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
+	int numRunning = 0, numWaiting = 0, numPersistent = 0, numTotal = 0;
+
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i]->_state == SCRIPT_FINISHED) {
+			continue;
+		}
+		switch (_scripts[i]->_state) {
+		case SCRIPT_RUNNING:
+		case SCRIPT_SLEEPING:
+		case SCRIPT_PAUSED:
+			numRunning++;
+			break;
+		case SCRIPT_WAITING:
+			numWaiting++;
+			break;
+		case SCRIPT_PERSISTENT:
+			numPersistent++;
+			break;
+		default:
+			warning("ScEngine::GetNumScripts - unhandled enum");
+			break;
+		}
+		numTotal++;
+	}
+	if (running) {
+		*running = numRunning;
+	}
+	if (waiting) {
+		*waiting = numWaiting;
+	}
+	if (persistent) {
+		*persistent = numPersistent;
+	}
+
+	return numTotal;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::emptyScriptCache() {
+	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
+		if (_cachedScripts[i]) {
+			delete _cachedScripts[i];
+			_cachedScripts[i] = NULL;
+		}
+	}
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::resetObject(BaseObject *Object) {
+	// terminate all scripts waiting for this object
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
+			if (!_gameRef->_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
+		}
+	}
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::resetScript(ScScript *script) {
+	// terminate all scripts waiting for this script
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i]->_state == SCRIPT_WAITING_SCRIPT && _scripts[i]->_waitScript == script) {
+			_scripts[i]->finish();
+		}
+	}
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::persist(BasePersistenceManager *persistMgr) {
+	if (!persistMgr->getIsSaving()) {
+		cleanup();
+	}
+
+	persistMgr->transfer(TMEMBER(_gameRef));
+	persistMgr->transfer(TMEMBER(_currentScript));
+	persistMgr->transfer(TMEMBER(_globals));
+	_scripts.persist(persistMgr);
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::editorCleanup() {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
+			delete _scripts[i];
+			_scripts.remove_at(i);
+			i--;
+		}
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::pauseAll() {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i] != _currentScript) {
+			_scripts[i]->pause();
+		}
+	}
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::resumeAll() {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		_scripts[i]->resume();
+	}
+
+	return STATUS_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::isValidScript(ScScript *script) {
+	for (uint32 i = 0; i < _scripts.size(); i++) {
+		if (_scripts[i] == script) {
+			return true;
+		}
+	}
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool ScEngine::clearGlobals(bool includingNatives) {
+	_globals->CleanProps(includingNatives);
+	return STATUS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::addScriptTime(const char *filename, uint32 time) {
+	if (!_isProfiling) {
+		return;
+	}
+
+	AnsiString fileName = filename;
+	fileName.toLowercase();
+	_scriptTimes[fileName] += time;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::enableProfiling() {
+	if (_isProfiling) {
+		return;
+	}
+
+	// destroy old data, if any
+	_scriptTimes.clear();
+
+	_profilingStartTime = g_system->getMillis();
+	_isProfiling = true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::disableProfiling() {
+	if (!_isProfiling) {
+		return;
+	}
+
+	dumpStats();
+	_isProfiling = false;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ScEngine::dumpStats() {
+	error("DumpStats not ported to ScummVM yet");
+	/*  uint32 totalTime = g_system->getMillis() - _profilingStartTime;
+
+	    typedef std::vector <std::pair<uint32, std::string> > TimeVector;
+	    TimeVector times;
+
+	    ScriptTimes::iterator it;
+	    for (it = _scriptTimes.begin(); it != _scriptTimes.end(); ++it) {
+	        times.push_back(std::pair<uint32, std::string> (it->_value, it->_key));
+	    }
+	    std::sort(times.begin(), times.end());
+
+
+	    TimeVector::reverse_iterator tit;
+
+	    _gameRef->LOG(0, "***** Script profiling information: *****");
+	    _gameRef->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
+
+	    for (tit = times.rbegin(); tit != times.rend(); ++tit) {
+	        _gameRef->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
+	    }*/
+}
+
+} // end of namespace Wintermute
-- 
cgit v1.2.3


From f33884b02091537275a17ff55ae756ff4e862c29 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Tue, 11 Sep 2012 03:40:56 +0200
Subject: WINTERMUTE: Remove a few more unused includes.

---
 engines/wintermute/base/scriptables/script_engine.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'engines/wintermute/base/scriptables/script_engine.cpp')

diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 20e2ccadd1..3d1863946e 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -33,7 +33,6 @@
 #include "engines/wintermute/base/scriptables/script_ext_math.h"
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_game.h"
-#include "engines/wintermute/base/sound/base_sound.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/utils/utils.h"
 
-- 
cgit v1.2.3