SAGA: changed _threadList back to a list of ScriptThread objs, instead of ptrs to instances.

svn-id: r39944

1 files changed, 56 insertions, 59 deletions

diff --git a/engines/saga/sthread.cpp b/engines/saga/sthread.cpp
index b6b0df9cc9..5edd40ac16 100644
--- a/engines/saga/sthread.cpp
+++ b/engines/saga/sthread.cpp
@@ -37,42 +37,40 @@
 
 namespace Saga {
 
-ScriptThread *Script::createThread(uint16 scriptModuleNumber, uint16 scriptEntryPointNumber) {
-	ScriptThread *newThread = new ScriptThread();
-
+ScriptThread &Script::createThread(uint16 scriptModuleNumber, uint16 scriptEntryPointNumber) {
 	loadModule(scriptModuleNumber);
 	if (_modules[scriptModuleNumber].entryPointsCount <= scriptEntryPointNumber) {
 		error("Script::createThread wrong scriptEntryPointNumber");
 	}
 
-	newThread->_flags = kTFlagNone;
-	newThread->_stackSize = DEFAULT_THREAD_STACK_SIZE;
-	newThread->_stackBuf = (uint16 *)malloc(newThread->_stackSize * sizeof(uint16));
-	newThread->_stackTopIndex = newThread->_stackSize - 2;
-	newThread->_instructionOffset = _modules[scriptModuleNumber].entryPoints[scriptEntryPointNumber].offset;
-	newThread->_commonBase = _commonBuffer;
-	newThread->_staticBase = _commonBuffer + _modules[scriptModuleNumber].staticOffset;
-	newThread->_moduleBase = _modules[scriptModuleNumber].moduleBase;
-	newThread->_moduleBaseSize = _modules[scriptModuleNumber].moduleBaseSize;
-	newThread->_strings = &_modules[scriptModuleNumber].strings;
+	ScriptThread newThread;
+	newThread._instructionOffset = _modules[scriptModuleNumber].entryPoints[scriptEntryPointNumber].offset;
+	newThread._commonBase = _commonBuffer;
+	newThread._staticBase = _commonBuffer + _modules[scriptModuleNumber].staticOffset;
+	newThread._moduleBase = _modules[scriptModuleNumber].moduleBase;
+	newThread._moduleBaseSize = _modules[scriptModuleNumber].moduleBaseSize;
+	newThread._strings = &_modules[scriptModuleNumber].strings;
 
 	if (_vm->getGameId() == GID_IHNM)
-		newThread->_voiceLUT = &_globalVoiceLUT;
+		newThread._voiceLUT = &_globalVoiceLUT;
 	else
-		newThread->_voiceLUT = &_modules[scriptModuleNumber].voiceLUT;
+		newThread._voiceLUT = &_modules[scriptModuleNumber].voiceLUT;
 
 	_threadList.push_front(newThread);
 
-	return newThread;
+	ScriptThread &tmp = *_threadList.begin();
+	tmp._stackBuf = (int16 *)malloc(ScriptThread::THREAD_STACK_SIZE * sizeof(int16));
+	tmp._stackTopIndex = ScriptThread::THREAD_STACK_SIZE - 2;
+	return tmp;
 }
 
 void Script::wakeUpActorThread(int waitType, void *threadObj) {
 	ScriptThreadList::iterator threadIterator;
 
 	for (threadIterator = _threadList.begin(); threadIterator != _threadList.end(); ++threadIterator) {
-		ScriptThread *thread = *threadIterator;
-		if ((thread->_flags & kTFlagWaiting) && (thread->_waitType == waitType) && (thread->_threadObj == threadObj)) {
-			thread->_flags &= ~kTFlagWaiting;
+		ScriptThread &thread = *threadIterator;
+		if ((thread._flags & kTFlagWaiting) && (thread._waitType == waitType) && (thread._threadObj == threadObj)) {
+			thread._flags &= ~kTFlagWaiting;
 		}
 	}
 }
@@ -81,9 +79,9 @@ void Script::wakeUpThreads(int waitType) {
 	ScriptThreadList::iterator threadIterator;
 
 	for (threadIterator = _threadList.begin(); threadIterator != _threadList.end(); ++threadIterator) {
-		ScriptThread *thread = *threadIterator;
-		if ((thread->_flags & kTFlagWaiting) && (thread->_waitType == waitType)) {
-			thread->_flags &= ~kTFlagWaiting;
+		ScriptThread &thread = *threadIterator;
+		if ((thread._flags & kTFlagWaiting) && (thread._waitType == waitType)) {
+			thread._flags &= ~kTFlagWaiting;
 		}
 	}
 }
@@ -92,10 +90,10 @@ void Script::wakeUpThreadsDelayed(int waitType, int sleepTime) {
 	ScriptThreadList::iterator threadIterator;
 
 	for (threadIterator = _threadList.begin(); threadIterator != _threadList.end(); ++threadIterator) {
-		ScriptThread *thread = *threadIterator;
-		if ((thread->_flags & kTFlagWaiting) && (thread->_waitType == waitType)) {
-			thread->_waitType = kWaitTypeDelay;
-			thread->_sleepTime = sleepTime;
+		ScriptThread &thread = *threadIterator;
+		if ((thread._flags & kTFlagWaiting) && (thread._waitType == waitType)) {
+			thread._waitType = kWaitTypeDelay;
+			thread._sleepTime = sleepTime;
 		}
 	}
 }
@@ -110,55 +108,54 @@ void Script::executeThreads(uint msec) {
 	threadIterator = _threadList.begin();
 
 	while (threadIterator != _threadList.end()) {
-		ScriptThread *thread = *threadIterator;
+		ScriptThread &thread = *threadIterator;
 
-		if (thread->_flags & (kTFlagFinished | kTFlagAborted)) {
-			if (thread->_flags & kTFlagFinished)
+		if (thread._flags & (kTFlagFinished | kTFlagAborted)) {
+			if (thread._flags & kTFlagFinished)
 				setPointerVerb();
 
 			if (_vm->getGameId() == GID_IHNM) {
-				thread->_flags &= ~kTFlagFinished;
-				thread->_flags |= kTFlagAborted;
+				thread._flags &= ~kTFlagFinished;
+				thread._flags |= kTFlagAborted;
 				++threadIterator;
 			} else {
-				delete *threadIterator;
 				threadIterator = _threadList.erase(threadIterator);
 			}
 			continue;
 		}
 
-		if (thread->_flags & kTFlagWaiting) {
+		if (thread._flags & kTFlagWaiting) {
 
-			switch (thread->_waitType) {
+			switch (thread._waitType) {
 			case kWaitTypeDelay:
-				if (thread->_sleepTime < msec) {
-					thread->_sleepTime = 0;
+				if (thread._sleepTime < msec) {
+					thread._sleepTime = 0;
 				} else {
-					thread->_sleepTime -= msec;
+					thread._sleepTime -= msec;
 				}
 
-				if (thread->_sleepTime == 0)
-					thread->_flags &= ~kTFlagWaiting;
+				if (thread._sleepTime == 0)
+					thread._flags &= ~kTFlagWaiting;
 				break;
 
 			case kWaitTypeWalk:
 				{
 					ActorData *actor;
-					actor = (ActorData *)thread->_threadObj;
+					actor = (ActorData *)thread._threadObj;
 					if (actor->_currentAction == kActionWait) {
-						thread->_flags &= ~kTFlagWaiting;
+						thread._flags &= ~kTFlagWaiting;
 					}
 				}
 				break;
 
 			case kWaitTypeWaitFrames: // IHNM
-				if (thread->_frameWait < _vm->_frameCount)
-					thread->_flags &= ~kTFlagWaiting;
+				if (thread._frameWait < _vm->_frameCount)
+					thread._flags &= ~kTFlagWaiting;
 				break;
 			}
 		}
 
-		if (!(thread->_flags & kTFlagWaiting)) {
+		if (!(thread._flags & kTFlagWaiting)) {
 			if (runThread(thread)) {
 				break;
 			}
@@ -175,8 +172,8 @@ void Script::abortAllThreads(void) {
 	threadIterator = _threadList.begin();
 
 	while (threadIterator != _threadList.end()) {
-		ScriptThread *thread = *threadIterator;
-		thread->_flags |= kTFlagAborted;
+		ScriptThread &thread = *threadIterator;
+		thread._flags |= kTFlagAborted;
 		++threadIterator;
 	}
 	executeThreads(0);
@@ -189,44 +186,44 @@ void Script::completeThread(void) {
 		executeThreads(0);
 }
 
-bool Script::runThread(ScriptThread *thread) {
+bool Script::runThread(ScriptThread &thread) {
 	uint16 savedInstructionOffset;
 	bool stopParsing = false;
 	bool breakOut = false;
 	int operandChar;
 
-	MemoryReadStream scriptS(thread->_moduleBase, thread->_moduleBaseSize);
+	MemoryReadStream scriptS(thread._moduleBase, thread._moduleBaseSize);
 
-	scriptS.seek(thread->_instructionOffset);
+	scriptS.seek(thread._instructionOffset);
 
 	for (uint instructionCount = 0; instructionCount < STHREAD_TIMESLICE; instructionCount++) {
-		if (thread->_flags & (kTFlagAsleep))
+		if (thread._flags & (kTFlagAsleep))
 			break;
 
-		savedInstructionOffset = thread->_instructionOffset;
+		savedInstructionOffset = thread._instructionOffset;
 		operandChar = scriptS.readByte();
 
-		debug(8, "Executing thread offset: %u (%x) stack: %d", thread->_instructionOffset, operandChar, thread->pushedSize());
+		debug(8, "Executing thread offset: %u (%x) stack: %d", thread._instructionOffset, operandChar, thread.pushedSize());
 
 		stopParsing = false;
 		debug(4, "Calling op %s", this->_scriptOpsList[operandChar].scriptOpName);
-		(this->*_scriptOpsList[operandChar].scriptOp)(thread, &scriptS, stopParsing, breakOut);
+		(this->*_scriptOpsList[operandChar].scriptOp)(&thread, &scriptS, stopParsing, breakOut);
 		if (stopParsing)
 			return breakOut;
 
-		if (thread->_flags & (kTFlagFinished | kTFlagAborted)) {
-			error("Wrong flags %d in thread", thread->_flags);
+		if (thread._flags & (kTFlagFinished | kTFlagAborted)) {
+			error("Wrong flags %d in thread", thread._flags);
 		}
 
 		// Set instruction offset only if a previous instruction didn't branch
-		if (savedInstructionOffset == thread->_instructionOffset) {
-			thread->_instructionOffset = scriptS.pos();
+		if (savedInstructionOffset == thread._instructionOffset) {
+			thread._instructionOffset = scriptS.pos();
 		} else {
-			if (thread->_instructionOffset >= scriptS.size()) {
+			if (thread._instructionOffset >= scriptS.size()) {
 				error("Script::runThread() Out of range script execution");
 			}
 
-			scriptS.seek(thread->_instructionOffset);
+			scriptS.seek(thread._instructionOffset);
 		}
 
 		if (breakOut)