WINTERMUTE: Rename FuncName->funcName in ScStack

12 files changed, 477 insertions, 477 deletions

diff --git a/engines/wintermute/Base/scriptables/SXArray.cpp b/engines/wintermute/Base/scriptables/SXArray.cpp
index 1a8dfdba64..c22dd9e4b5 100644
--- a/engines/wintermute/Base/scriptables/SXArray.cpp
+++ b/engines/wintermute/Base/scriptables/SXArray.cpp
@@ -45,15 +45,15 @@ CSXArray::CSXArray(CBGame *inGame, CScStack *stack): CBScriptable(inGame) {
 	_length = 0;

 	_values = new CScValue(Game);

 

-	int NumParams = stack->Pop()->GetInt(0);

+	int NumParams = stack->pop()->GetInt(0);

 

-	if (NumParams == 1) _length = stack->Pop()->GetInt(0);

+	if (NumParams == 1) _length = stack->pop()->GetInt(0);

 	else if (NumParams > 1) {

 		_length = NumParams;

 		char ParamName[20];

 		for (int i = 0; i < NumParams; i++) {

 			sprintf(ParamName, "%d", i);

-			_values->SetProp(ParamName, stack->Pop());

+			_values->SetProp(ParamName, stack->pop());

 		}

 	}

 }

@@ -98,15 +98,15 @@ HRESULT CSXArray::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// Push

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "Push") == 0) {

-		int NumParams = stack->Pop()->GetInt(0);

+		int NumParams = stack->pop()->GetInt(0);

 		char ParamName[20];

 

 		for (int i = 0; i < NumParams; i++) {

 			_length++;

 			sprintf(ParamName, "%d", _length - 1);

-			_values->SetProp(ParamName, stack->Pop(), true);

+			_values->SetProp(ParamName, stack->pop(), true);

 		}

-		stack->PushInt(_length);

+		stack->pushInt(_length);

 

 		return S_OK;

 	}

@@ -116,15 +116,15 @@ HRESULT CSXArray::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "Pop") == 0) {

 

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 

 		if (_length > 0) {

 			char ParamName[20];

 			sprintf(ParamName, "%d", _length - 1);

-			stack->Push(_values->GetProp(ParamName));

+			stack->push(_values->GetProp(ParamName));

 			_values->DeleteProp(ParamName);

 			_length--;

-		} else stack->PushNULL();

+		} else stack->pushNULL();

 

 		return S_OK;

 	}

diff --git a/engines/wintermute/Base/scriptables/SXDate.cpp b/engines/wintermute/Base/scriptables/SXDate.cpp
index 5026ebdd8e..61a646df43 100644
--- a/engines/wintermute/Base/scriptables/SXDate.cpp
+++ b/engines/wintermute/Base/scriptables/SXDate.cpp
@@ -40,17 +40,17 @@ CBScriptable *makeSXDate(CBGame *inGame, CScStack *stack) {
 

 //////////////////////////////////////////////////////////////////////////

 CSXDate::CSXDate(CBGame *inGame, CScStack *stack): CBScriptable(inGame) {

-	stack->CorrectParams(6);

+	stack->correctParams(6);

 

 	memset(&_tm, 0, sizeof(_tm));

 

-	CScValue *valYear = stack->Pop();

+	CScValue *valYear = stack->pop();

 	_tm.tm_year = valYear->GetInt() - 1900;

-	_tm.tm_mon = stack->Pop()->GetInt() - 1;

-	_tm.tm_mday = stack->Pop()->GetInt();

-	_tm.tm_hour = stack->Pop()->GetInt();

-	_tm.tm_min = stack->Pop()->GetInt();

-	_tm.tm_sec = stack->Pop()->GetInt();

+	_tm.tm_mon = stack->pop()->GetInt() - 1;

+	_tm.tm_mday = stack->pop()->GetInt();

+	_tm.tm_hour = stack->pop()->GetInt();

+	_tm.tm_min = stack->pop()->GetInt();

+	_tm.tm_sec = stack->pop()->GetInt();

 

 	if (valYear->IsNULL()) {

 		g_system->getTimeAndDate(_tm);

@@ -80,57 +80,57 @@ HRESULT CSXDate::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// GetYear

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "GetYear") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_year + 1900);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_year + 1900);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetMonth

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetMonth") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_mon + 1);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_mon + 1);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetDate

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetDate") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_mday);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_mday);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetHours

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetHours") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_hour);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_hour);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetMinutes

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetMinutes") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_min);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_min);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetSeconds

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetSeconds") == 0) {

-		stack->CorrectParams(0);

-		stack->PushInt(_tm.tm_sec);

+		stack->correctParams(0);

+		stack->pushInt(_tm.tm_sec);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetWeekday

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetWeekday") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		warning("GetWeekday returns a wrong value on purpose");

-		stack->PushInt(_tm.tm_mday % 7);

+		stack->pushInt(_tm.tm_mday % 7);

 		return S_OK;

 	}

 

@@ -139,54 +139,54 @@ HRESULT CSXDate::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// SetYear

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetYear") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_year = stack->Pop()->GetInt() - 1900;

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_year = stack->pop()->GetInt() - 1900;

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// SetMonth

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetMonth") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_mon = stack->Pop()->GetInt() - 1;

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_mon = stack->pop()->GetInt() - 1;

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// SetDate

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetDate") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_mday = stack->Pop()->GetInt();

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_mday = stack->pop()->GetInt();

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// SetHours

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetHours") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_hour = stack->Pop()->GetInt();

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_hour = stack->pop()->GetInt();

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// SetMinutes

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetMinutes") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_min = stack->Pop()->GetInt();

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_min = stack->pop()->GetInt();

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// SetSeconds

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetSeconds") == 0) {

-		stack->CorrectParams(1);

-		_tm.tm_sec = stack->Pop()->GetInt();

-		stack->PushNULL();

+		stack->correctParams(1);

+		_tm.tm_sec = stack->pop()->GetInt();

+		stack->pushNULL();

 		return S_OK;

 	}

 

@@ -195,9 +195,9 @@ HRESULT CSXDate::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// SetCurrentTime

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetCurrentTime") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		g_system->getTimeAndDate(_tm);

-		stack->PushNULL();

+		stack->pushNULL();

 		return S_OK;

 	}

 

diff --git a/engines/wintermute/Base/scriptables/SXFile.cpp b/engines/wintermute/Base/scriptables/SXFile.cpp
index b897ca9701..fc2fca1991 100644
--- a/engines/wintermute/Base/scriptables/SXFile.cpp
+++ b/engines/wintermute/Base/scriptables/SXFile.cpp
@@ -56,8 +56,8 @@ CBScriptable *makeSXFile(CBGame *inGame, CScStack *stack) {
 

 //////////////////////////////////////////////////////////////////////////

 CSXFile::CSXFile(CBGame *inGame, CScStack *stack): CBScriptable(inGame) {

-	stack->CorrectParams(1);

-	CScValue *Val = stack->Pop();

+	stack->correctParams(1);

+	CScValue *Val = stack->pop();

 

 	_filename = NULL;

 	if (!Val->IsNULL()) CBUtils::SetString(&_filename, Val->GetString());

@@ -110,11 +110,11 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// SetFilename

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "SetFilename") == 0) {

-		stack->CorrectParams(1);

-		const char *Filename = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *Filename = stack->pop()->GetString();

 		cleanup();

 		CBUtils::SetString(&_filename, Filename);

-		stack->PushNULL();

+		stack->pushNULL();

 		return S_OK;

 	}

 

@@ -122,9 +122,9 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// OpenAsText / OpenAsBinary

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "OpenAsText") == 0 || strcmp(name, "OpenAsBinary") == 0) {

-		stack->CorrectParams(1);

+		stack->correctParams(1);

 		Close();

-		_mode = stack->Pop()->GetInt(1);

+		_mode = stack->pop()->GetInt(1);

 		if (_mode < 1 || _mode > 3) {

 			script->RuntimeError("File.%s: invalid access mode. Setting read mode.", name);

 			_mode = 1;

@@ -150,8 +150,8 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 			} else _textMode = strcmp(name, "OpenAsText") == 0;

 		}

 

-		if (_readFile || _writeFile) stack->PushBool(true);

-		else stack->PushBool(false);

+		if (_readFile || _writeFile) stack->pushBool(true);

+		else stack->pushBool(false);

 

 		return S_OK;

 	}

@@ -160,9 +160,9 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Close

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Close") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		Close();

-		stack->PushNULL();

+		stack->pushNULL();

 		return S_OK;

 	}

 

@@ -170,13 +170,13 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// SetPosition

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetPosition") == 0) {

-		stack->CorrectParams(1);

+		stack->correctParams(1);

 		if (_mode == 0) {

 			script->RuntimeError("File.%s: File is not open", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 		} else {

-			int Pos = stack->Pop()->GetInt();

-			stack->PushBool(SetPos(Pos));

+			int Pos = stack->pop()->GetInt();

+			stack->pushBool(SetPos(Pos));

 		}

 		return S_OK;

 	}

@@ -185,9 +185,9 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Delete

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Delete") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		Close();

-		stack->PushBool(CBPlatform::DeleteFile(_filename) != false);

+		stack->pushBool(CBPlatform::DeleteFile(_filename) != false);

 		return S_OK;

 	}

 

@@ -195,12 +195,12 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Copy

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Copy") == 0) {

-		stack->CorrectParams(2);

-		const char *Dest = stack->Pop()->GetString();

-		bool Overwrite = stack->Pop()->GetBool(true);

+		stack->correctParams(2);

+		const char *Dest = stack->pop()->GetString();

+		bool Overwrite = stack->pop()->GetBool(true);

 

 		Close();

-		stack->PushBool(CBPlatform::CopyFile(_filename, Dest, !Overwrite) != false);

+		stack->pushBool(CBPlatform::CopyFile(_filename, Dest, !Overwrite) != false);

 		return S_OK;

 	}

 

@@ -208,10 +208,10 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadLine

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadLine") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (!_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open in text mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		uint32 BufSize = FILE_BUFFER_SIZE;

@@ -245,8 +245,8 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 		}

 		Buf[Counter] = '\0';

 

-		if (!FoundNewLine && Counter == 0) stack->PushNULL();

-		else stack->PushString((char *)Buf);

+		if (!FoundNewLine && Counter == 0) stack->pushNULL();

+		else stack->pushString((char *)Buf);

 

 		free(Buf);

 

@@ -257,12 +257,12 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadText

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadText") == 0) {

-		stack->CorrectParams(1);

-		int TextLen = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int TextLen = stack->pop()->GetInt();

 

 		if (!_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open in text mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		uint32 BufSize = FILE_BUFFER_SIZE;

@@ -292,8 +292,8 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 		}

 		Buf[Counter] = '\0';

 

-		if (TextLen > 0 && Counter == 0) stack->PushNULL();

-		else stack->PushString((char *)Buf);

+		if (TextLen > 0 && Counter == 0) stack->pushNULL();

+		else stack->pushString((char *)Buf);

 

 		free(Buf);

 

@@ -304,11 +304,11 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteLine / WriteText

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteLine") == 0 || strcmp(name, "WriteText") == 0) {

-		stack->CorrectParams(1);

-		const char *Line = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *Line = stack->pop()->GetString();

 		if (!_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in text mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		if (strcmp(name, "WriteLine") == 0)

@@ -316,7 +316,7 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 		else

 			fprintf((FILE *)_writeFile, "%s", Line);

 

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -326,15 +326,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadBool

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadBool") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		bool Val;

-		if (_readFile->read(&Val, sizeof(bool)) == sizeof(bool)) stack->PushBool(Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(bool)) == sizeof(bool)) stack->pushBool(Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -343,15 +343,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadByte

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadByte") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		byte Val;

-		if (_readFile->read(&Val, sizeof(byte)) == sizeof(byte)) stack->PushInt(Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(byte)) == sizeof(byte)) stack->pushInt(Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -360,15 +360,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadShort

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadShort") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		short Val;

-		if (_readFile->read(&Val, sizeof(short)) == sizeof(short)) stack->PushInt(65536 + Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(short)) == sizeof(short)) stack->pushInt(65536 + Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -377,15 +377,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadInt / ReadLong

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadInt") == 0 || strcmp(name, "ReadLong") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		int Val;

-		if (_readFile->read(&Val, sizeof(int)) == sizeof(int)) stack->PushInt(Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(int)) == sizeof(int)) stack->pushInt(Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -394,15 +394,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadFloat

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadFloat") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		float Val;

-		if (_readFile->read(&Val, sizeof(float)) == sizeof(float)) stack->PushFloat(Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(float)) == sizeof(float)) stack->pushFloat(Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -411,15 +411,15 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadDouble

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadDouble") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		double Val;

-		if (_readFile->read(&Val, sizeof(double)) == sizeof(double)) stack->PushFloat(Val);

-		else stack->PushNULL();

+		if (_readFile->read(&Val, sizeof(double)) == sizeof(double)) stack->pushFloat(Val);

+		else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -428,10 +428,10 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// ReadString

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ReadString") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_textMode || !_readFile) {

 			script->RuntimeError("File.%s: File must be open for reading in binary mode.", name);

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 		uint32 Size;

@@ -440,11 +440,11 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 			if (Str) {

 				if (_readFile->read(Str, Size) == Size) {

 					Str[Size] = '\0';

-					stack->PushString((char *)Str);

+					stack->pushString((char *)Str);

 				}

 				delete [] Str;

-			} else stack->PushNULL();

-		} else stack->PushNULL();

+			} else stack->pushNULL();

+		} else stack->pushNULL();

 

 		return S_OK;

 	}

@@ -453,16 +453,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteBool

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteBool") == 0) {

-		stack->CorrectParams(1);

-		bool Val = stack->Pop()->GetBool();

+		stack->correctParams(1);

+		bool Val = stack->pop()->GetBool();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -471,16 +471,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteByte

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteByte") == 0) {

-		stack->CorrectParams(1);

-		byte Val = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		byte Val = stack->pop()->GetInt();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -489,16 +489,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteShort

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteShort") == 0) {

-		stack->CorrectParams(1);

-		short Val = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		short Val = stack->pop()->GetInt();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -507,16 +507,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteInt / WriteLong

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteInt") == 0 || strcmp(name, "WriteLong") == 0) {

-		stack->CorrectParams(1);

-		int Val = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int Val = stack->pop()->GetInt();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -525,16 +525,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteFloat

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteFloat") == 0) {

-		stack->CorrectParams(1);

-		float Val = stack->Pop()->GetFloat();

+		stack->correctParams(1);

+		float Val = stack->pop()->GetFloat();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -543,16 +543,16 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteDouble

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteDouble") == 0) {

-		stack->CorrectParams(1);

-		double Val = stack->Pop()->GetFloat();

+		stack->correctParams(1);

+		double Val = stack->pop()->GetFloat();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 		fwrite(&Val, sizeof(Val), 1, (FILE *)_writeFile);

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -561,12 +561,12 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// WriteString

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "WriteString") == 0) {

-		stack->CorrectParams(1);

-		const char *Val = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *Val = stack->pop()->GetString();

 

 		if (_textMode || !_writeFile) {

 			script->RuntimeError("File.%s: File must be open for writing in binary mode.", name);

-			stack->PushBool(false);

+			stack->pushBool(false);

 			return S_OK;

 		}

 

@@ -574,7 +574,7 @@ HRESULT CSXFile::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 		fwrite(&Size, sizeof(Size), 1, (FILE *)_writeFile);

 		fwrite(Val, Size, 1, (FILE *)_writeFile);

 

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

diff --git a/engines/wintermute/Base/scriptables/SXMath.cpp b/engines/wintermute/Base/scriptables/SXMath.cpp
index a9337af1a8..110330d4ef 100644
--- a/engines/wintermute/Base/scriptables/SXMath.cpp
+++ b/engines/wintermute/Base/scriptables/SXMath.cpp
@@ -63,8 +63,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Abs

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "Abs") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(fabs(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(fabs(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -72,8 +72,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Acos

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Acos") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(acos(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(acos(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -81,8 +81,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Asin

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Asin") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(asin(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(asin(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -90,8 +90,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Atan

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Atan") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(atan(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(atan(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -99,10 +99,10 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Atan2

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Atan2") == 0) {

-		stack->CorrectParams(2);

-		double y = stack->Pop()->GetFloat();

-		double x = stack->Pop()->GetFloat();

-		stack->PushFloat(atan2(y, x));

+		stack->correctParams(2);

+		double y = stack->pop()->GetFloat();

+		double x = stack->pop()->GetFloat();

+		stack->pushFloat(atan2(y, x));

 		return S_OK;

 	}

 

@@ -110,8 +110,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Ceil

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Ceil") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(ceil(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(ceil(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -119,8 +119,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Cos

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Cos") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(cos(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(cos(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -128,8 +128,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Cosh

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Cosh") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(cosh(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(cosh(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -137,8 +137,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Exp

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Exp") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(exp(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(exp(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -146,8 +146,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Floor

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Floor") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(floor(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(floor(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -155,8 +155,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Log

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Log") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(log(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(log(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -164,8 +164,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Log10

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Log10") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(log10(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(log10(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -173,11 +173,11 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Pow

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Pow") == 0) {

-		stack->CorrectParams(2);

-		double x = stack->Pop()->GetFloat();

-		double y = stack->Pop()->GetFloat();

+		stack->correctParams(2);

+		double x = stack->pop()->GetFloat();

+		double y = stack->pop()->GetFloat();

 

-		stack->PushFloat(pow(x, y));

+		stack->pushFloat(pow(x, y));

 		return S_OK;

 	}

 

@@ -185,8 +185,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Sin

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Sin") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(sin(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(sin(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -194,8 +194,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Sinh

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Sinh") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(sinh(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(sinh(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -203,8 +203,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Tan

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Tan") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(tan(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(tan(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -212,8 +212,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Tanh

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Tanh") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(tanh(DegreeToRadian(stack->Pop()->GetFloat())));

+		stack->correctParams(1);

+		stack->pushFloat(tanh(DegreeToRadian(stack->pop()->GetFloat())));

 		return S_OK;

 	}

 

@@ -221,8 +221,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// Sqrt

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Sqrt") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(sqrt(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(sqrt(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -230,8 +230,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// DegToRad

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "DegToRad") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(DegreeToRadian(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(DegreeToRadian(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

@@ -239,8 +239,8 @@ HRESULT CSXMath::scCallMethod(CScScript *script, CScStack *stack, CScStack *this
 	// RadToDeg

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "RadToDeg") == 0) {

-		stack->CorrectParams(1);

-		stack->PushFloat(RadianToDegree(stack->Pop()->GetFloat()));

+		stack->correctParams(1);

+		stack->pushFloat(RadianToDegree(stack->pop()->GetFloat()));

 		return S_OK;

 	}

 

diff --git a/engines/wintermute/Base/scriptables/SXMemBuffer.cpp b/engines/wintermute/Base/scriptables/SXMemBuffer.cpp
index 82a9a1f5e2..7dcb6ea1a7 100644
--- a/engines/wintermute/Base/scriptables/SXMemBuffer.cpp
+++ b/engines/wintermute/Base/scriptables/SXMemBuffer.cpp
@@ -43,11 +43,11 @@ CBScriptable *makeSXMemBuffer(CBGame *inGame, CScStack *stack) {
 

 //////////////////////////////////////////////////////////////////////////

 CSXMemBuffer::CSXMemBuffer(CBGame *inGame, CScStack *stack): CBScriptable(inGame) {

-	stack->CorrectParams(1);

+	stack->correctParams(1);

 	_buffer = NULL;

 	_size = 0;

 

-	int NewSize = stack->Pop()->GetInt();

+	int NewSize = stack->pop()->GetInt();

 	Resize(MAX(0, NewSize));

 }

 

@@ -127,11 +127,11 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetSize

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "SetSize") == 0) {

-		stack->CorrectParams(1);

-		int NewSize = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int NewSize = stack->pop()->GetInt();

 		NewSize = MAX(0, NewSize);

-		if (SUCCEEDED(Resize(NewSize))) stack->PushBool(true);

-		else stack->PushBool(false);

+		if (SUCCEEDED(Resize(NewSize))) stack->pushBool(true);

+		else stack->pushBool(false);

 

 		return S_OK;

 	}

@@ -140,10 +140,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetBool

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetBool") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(bool))) stack->PushNULL();

-		else stack->PushBool(*(bool *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(bool))) stack->pushNULL();

+		else stack->pushBool(*(bool *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -152,10 +152,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetByte

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetByte") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(byte))) stack->PushNULL();

-		else stack->PushInt(*(byte *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(byte))) stack->pushNULL();

+		else stack->pushInt(*(byte *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -164,10 +164,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetShort

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetShort") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(short))) stack->PushNULL();

-		else stack->PushInt(65536 + * (short *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(short))) stack->pushNULL();

+		else stack->pushInt(65536 + * (short *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -176,10 +176,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetInt / GetLong

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetInt") == 0 || strcmp(name, "GetLong") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(int))) stack->PushNULL();

-		else stack->PushInt(*(int *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(int))) stack->pushNULL();

+		else stack->pushInt(*(int *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -188,10 +188,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetFloat

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetFloat") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(float))) stack->PushNULL();

-		else stack->PushFloat(*(float *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(float))) stack->pushNULL();

+		else stack->pushFloat(*(float *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -200,10 +200,10 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetDouble

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetDouble") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(double))) stack->PushNULL();

-		else stack->PushFloat(*(double *)((byte *)_buffer + Start));

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(double))) stack->pushNULL();

+		else stack->pushFloat(*(double *)((byte *)_buffer + Start));

 

 		return S_OK;

 	}

@@ -212,9 +212,9 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetString

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetString") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		int Length = stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		int Length = stack->pop()->GetInt();

 

 		// find end of string

 		if (Length == 0 && Start >= 0 && Start < _size) {

@@ -226,12 +226,12 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 			}

 		}

 

-		if (!CheckBounds(script, Start, Length)) stack->PushNULL();

+		if (!CheckBounds(script, Start, Length)) stack->pushNULL();

 		else {

 			char *Str = new char[Length + 1];

 			strncpy(Str, (const char *)_buffer + Start, Length);

 			Str[Length] = '\0';

-			stack->PushString(Str);

+			stack->pushString(Str);

 			delete [] Str;

 		}

 		return S_OK;

@@ -241,13 +241,13 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// GetPointer

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetPointer") == 0) {

-		stack->CorrectParams(1);

-		int Start = stack->Pop()->GetInt();

-		if (!CheckBounds(script, Start, sizeof(void *))) stack->PushNULL();

+		stack->correctParams(1);

+		int Start = stack->pop()->GetInt();

+		if (!CheckBounds(script, Start, sizeof(void *))) stack->pushNULL();

 		else {

 			void *Pointer = *(void **)((byte *)_buffer + Start);

 			CSXMemBuffer *Buf = new CSXMemBuffer(Game, Pointer);

-			stack->PushNative(Buf, false);

+			stack->pushNative(Buf, false);

 		}

 		return S_OK;

 	}

@@ -256,14 +256,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetBool

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetBool") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		bool Val = stack->Pop()->GetBool();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		bool Val = stack->pop()->GetBool();

 

-		if (!CheckBounds(script, Start, sizeof(bool))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(bool))) stack->pushBool(false);

 		else {

 			*(bool *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -272,14 +272,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetByte

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetByte") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		byte Val = (byte)stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		byte Val = (byte)stack->pop()->GetInt();

 

-		if (!CheckBounds(script, Start, sizeof(byte))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(byte))) stack->pushBool(false);

 		else {

 			*(byte *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -288,14 +288,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetShort

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetShort") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		short Val = (short)stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		short Val = (short)stack->pop()->GetInt();

 

-		if (!CheckBounds(script, Start, sizeof(short))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(short))) stack->pushBool(false);

 		else {

 			*(short *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -304,14 +304,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetInt / SetLong

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetInt") == 0 || strcmp(name, "SetLong") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		int Val = stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		int Val = stack->pop()->GetInt();

 

-		if (!CheckBounds(script, Start, sizeof(int))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(int))) stack->pushBool(false);

 		else {

 			*(int *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -320,14 +320,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetFloat

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetFloat") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		float Val = (float)stack->Pop()->GetFloat();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		float Val = (float)stack->pop()->GetFloat();

 

-		if (!CheckBounds(script, Start, sizeof(float))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(float))) stack->pushBool(false);

 		else {

 			*(float *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -336,14 +336,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetDouble

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetDouble") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		double Val = stack->Pop()->GetFloat();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		double Val = stack->pop()->GetFloat();

 

-		if (!CheckBounds(script, Start, sizeof(double))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(double))) stack->pushBool(false);

 		else {

 			*(double *)((byte *)_buffer + Start) = Val;

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -352,14 +352,14 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetString

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetString") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		const char *Val = stack->Pop()->GetString();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		const char *Val = stack->pop()->GetString();

 

-		if (!CheckBounds(script, Start, strlen(Val) + 1)) stack->PushBool(false);

+		if (!CheckBounds(script, Start, strlen(Val) + 1)) stack->pushBool(false);

 		else {

 			memcpy((byte *)_buffer + Start, Val, strlen(Val) + 1);

-			stack->PushBool(true);

+			stack->pushBool(true);

 		}

 		return S_OK;

 	}

@@ -368,19 +368,19 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// SetPointer

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "SetPointer") == 0) {

-		stack->CorrectParams(2);

-		int Start = stack->Pop()->GetInt();

-		/* CScValue *Val = */ stack->Pop();

+		stack->correctParams(2);

+		int Start = stack->pop()->GetInt();

+		/* CScValue *Val = */ stack->pop();

 

-		if (!CheckBounds(script, Start, sizeof(void *))) stack->PushBool(false);

+		if (!CheckBounds(script, Start, sizeof(void *))) stack->pushBool(false);

 		else {

 			/*

 			int Pointer = (int)Val->GetMemBuffer();

 			memcpy((byte *)_buffer+Start, &Pointer, sizeof(void*));

-			stack->PushBool(true);

+			stack->pushBool(true);

 			*/

 			// TODO fix

-			stack->PushBool(false);

+			stack->pushBool(false);

 

 		}

 		return S_OK;

@@ -390,7 +390,7 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 	// DEBUG_Dump

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "DEBUG_Dump") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		if (_buffer && _size) {

 			warning("SXMemBuffer::ScCallMethod - DEBUG_Dump");

 			Common::DumpFile f;

@@ -398,7 +398,7 @@ HRESULT CSXMemBuffer::scCallMethod(CScScript *script, CScStack *stack, CScStack
 			f.write(_buffer, _size);

 			f.close();

 		}

-		stack->PushNULL();

+		stack->pushNULL();

 		return S_OK;

 	}

 

diff --git a/engines/wintermute/Base/scriptables/SXStore.cpp b/engines/wintermute/Base/scriptables/SXStore.cpp
index bfdbd212c7..a1d41c2db6 100644
--- a/engines/wintermute/Base/scriptables/SXStore.cpp
+++ b/engines/wintermute/Base/scriptables/SXStore.cpp
@@ -89,39 +89,39 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// EnableEvents

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "EnableEvents") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		SetEventsEnabled(script, true);

-		stack->PushBool(GetEventsEnabled() == true);

+		stack->pushBool(GetEventsEnabled() == true);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// DisableEvents

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "DisableEvents") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		SetEventsEnabled(script, false);

-		stack->PushBool(GetEventsEnabled() == false);

+		stack->pushBool(GetEventsEnabled() == false);

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// ValidateProducts

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ValidateProducts") == 0) {

-		stack->CorrectParams(1);

-		const char *prodIdList = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *prodIdList = stack->pop()->GetString();

 		_lastProductRequestOwner = script->_owner;

 		ValidateProducts(prodIdList);

-		stack->PushNULL();

+		stack->pushNULL();

 		return S_OK;

 	}

 	//////////////////////////////////////////////////////////////////////////

 	// GetValidProduct

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetValidProduct") == 0) {

-		stack->CorrectParams(1);

-		int index = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int index = stack->pop()->GetInt();

 		if (index >= 0 && index < _validProducts.GetSize()) {

-			CScValue *prod = stack->GetPushValue();

+			CScValue *prod = stack->getPushValue();

 			if (prod) {

 				prod->SetProperty("Id", _validProducts[index]->GetId());

 				prod->SetProperty("Name", _validProducts[index]->GetName());

@@ -129,7 +129,7 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 				prod->SetProperty("Price", _validProducts[index]->GetPrice());

 			}

 		} else

-			stack->PushNULL();

+			stack->pushNULL();

 

 		return S_OK;

 	}

@@ -137,12 +137,12 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// GetInvalidProduct

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetInvalidProduct") == 0) {

-		stack->CorrectParams(1);

-		int index = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int index = stack->pop()->GetInt();

 		if (index >= 0 && index < _invalidProducts.size())

-			stack->PushString(_invalidProducts[index].c_str());

+			stack->pushString(_invalidProducts[index].c_str());

 		else

-			stack->PushNULL();

+			stack->pushNULL();

 

 		return S_OK;

 	}

@@ -150,17 +150,17 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// GetTransaction

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "GetTransaction") == 0) {

-		stack->CorrectParams(1);

-		int index = stack->Pop()->GetInt();

+		stack->correctParams(1);

+		int index = stack->pop()->GetInt();

 		if (index >= 0 && index < _transactions.GetSize()) {

-			CScValue *trans = stack->GetPushValue();

+			CScValue *trans = stack->getPushValue();

 			if (trans) {

 				trans->SetProperty("Id", _transactions[index]->GetId());

 				trans->SetProperty("ProductId", _transactions[index]->GetProductId());

 				trans->SetProperty("State", _transactions[index]->GetState());

 			}

 		} else

-			stack->PushNULL();

+			stack->pushNULL();

 

 		return S_OK;

 	}

@@ -168,9 +168,9 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// Purchase

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Purchase") == 0) {

-		stack->CorrectParams(1);

-		const char *prodId = stack->Pop()->GetString();

-		stack->PushBool(Purchase(script, prodId));

+		stack->correctParams(1);

+		const char *prodId = stack->pop()->GetString();

+		stack->pushBool(Purchase(script, prodId));

 

 		return S_OK;

 	}

@@ -178,9 +178,9 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// FinishTransaction

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "FinishTransaction") == 0) {

-		stack->CorrectParams(1);

-		const char *transId = stack->Pop()->GetString();

-		stack->PushBool(FinishTransaction(script, transId));

+		stack->correctParams(1);

+		const char *transId = stack->pop()->GetString();

+		stack->pushBool(FinishTransaction(script, transId));

 

 		return S_OK;

 	}

@@ -188,9 +188,9 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// RestoreTransactions

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "RestoreTransactions") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 		RestoreTransactions(script);

-		stack->PushNULL();

+		stack->pushNULL();

 

 		return S_OK;

 	}

@@ -199,13 +199,13 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// UnlockProduct

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "UnlockProduct") == 0) {

-		stack->CorrectParams(1);

-		const char *prodId = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *prodId = stack->pop()->GetString();

 

 		Game->_registry->WriteBool("Purchases", prodId, true);

 		Game->_registry->SaveValues();

 

-		stack->PushBool(true);

+		stack->pushBool(true);

 

 		return S_OK;

 	}

@@ -214,10 +214,10 @@ HRESULT CSXStore::scCallMethod(CScScript *script, CScStack *stack, CScStack *thi
 	// IsProductUnlocked

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "IsProductUnlocked") == 0) {

-		stack->CorrectParams(1);

-		const char *prodId = stack->Pop()->GetString();

+		stack->correctParams(1);

+		const char *prodId = stack->pop()->GetString();

 

-		stack->PushBool(Game->_registry->ReadBool("Purchases", prodId, false));

+		stack->pushBool(Game->_registry->ReadBool("Purchases", prodId, false));

 

 		return S_OK;

 	}

diff --git a/engines/wintermute/Base/scriptables/SXString.cpp b/engines/wintermute/Base/scriptables/SXString.cpp
index 4a912df5fe..36dc257229 100644
--- a/engines/wintermute/Base/scriptables/SXString.cpp
+++ b/engines/wintermute/Base/scriptables/SXString.cpp
@@ -48,8 +48,8 @@ CSXString::CSXString(CBGame *inGame, CScStack *stack): CBScriptable(inGame) {
 	_string = NULL;

 	_capacity = 0;

 

-	stack->CorrectParams(1);

-	CScValue *Val = stack->Pop();

+	stack->correctParams(1);

+	CScValue *Val = stack->pop();

 

 	if (Val->IsInt()) {

 		_capacity = MAX(0, Val->GetInt());

@@ -104,9 +104,9 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// Substring

 	//////////////////////////////////////////////////////////////////////////

 	if (strcmp(name, "Substring") == 0) {

-		stack->CorrectParams(2);

-		int start = stack->Pop()->GetInt();

-		int end   = stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int start = stack->pop()->GetInt();

+		int end   = stack->pop()->GetInt();

 

 		if (end < start) CBUtils::Swap(&start, &end);

 

@@ -121,11 +121,11 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		WideString subStr(str.c_str() + start, end - start + 1);

 

 		if (Game->_textEncoding == TEXT_UTF8)

-			stack->PushString(StringUtil::WideToUtf8(subStr).c_str());

+			stack->pushString(StringUtil::WideToUtf8(subStr).c_str());

 		else

-			stack->PushString(StringUtil::WideToAnsi(subStr).c_str());

+			stack->pushString(StringUtil::WideToAnsi(subStr).c_str());

 		//  } catch (std::exception &) {

-		//      stack->PushNULL();

+		//      stack->pushNULL();

 		//  }

 

 		return S_OK;

@@ -135,14 +135,14 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// Substr

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Substr") == 0) {

-		stack->CorrectParams(2);

-		int start = stack->Pop()->GetInt();

+		stack->correctParams(2);

+		int start = stack->pop()->GetInt();

 

-		CScValue *val = stack->Pop();

+		CScValue *val = stack->pop();

 		int len = val->GetInt();

 

 		if (!val->IsNULL() && len <= 0) {

-			stack->PushString("");

+			stack->pushString("");

 			return S_OK;

 		}

 

@@ -159,11 +159,11 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		WideString subStr(str.c_str() + start, len);

 

 		if (Game->_textEncoding == TEXT_UTF8)

-			stack->PushString(StringUtil::WideToUtf8(subStr).c_str());

+			stack->pushString(StringUtil::WideToUtf8(subStr).c_str());

 		else

-			stack->PushString(StringUtil::WideToAnsi(subStr).c_str());

+			stack->pushString(StringUtil::WideToAnsi(subStr).c_str());

 //		} catch (std::exception &) {

-//			stack->PushNULL();

+//			stack->pushNULL();

 //		}

 

 		return S_OK;

@@ -173,7 +173,7 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// ToUpperCase

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ToUpperCase") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 

 		WideString str;

 		if (Game->_textEncoding == TEXT_UTF8)

@@ -184,9 +184,9 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		StringUtil::ToUpperCase(str);

 

 		if (Game->_textEncoding == TEXT_UTF8)

-			stack->PushString(StringUtil::WideToUtf8(str).c_str());

+			stack->pushString(StringUtil::WideToUtf8(str).c_str());

 		else

-			stack->PushString(StringUtil::WideToAnsi(str).c_str());

+			stack->pushString(StringUtil::WideToAnsi(str).c_str());

 

 		return S_OK;

 	}

@@ -195,7 +195,7 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// ToLowerCase

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "ToLowerCase") == 0) {

-		stack->CorrectParams(0);

+		stack->correctParams(0);

 

 		WideString str;

 		if (Game->_textEncoding == TEXT_UTF8)

@@ -206,9 +206,9 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		StringUtil::ToLowerCase(str);

 

 		if (Game->_textEncoding == TEXT_UTF8)

-			stack->PushString(StringUtil::WideToUtf8(str).c_str());

+			stack->pushString(StringUtil::WideToUtf8(str).c_str());

 		else

-			stack->PushString(StringUtil::WideToAnsi(str).c_str());

+			stack->pushString(StringUtil::WideToAnsi(str).c_str());

 

 		return S_OK;

 	}

@@ -217,10 +217,10 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// IndexOf

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "IndexOf") == 0) {

-		stack->CorrectParams(2);

+		stack->correctParams(2);

 

-		const char *strToFind = stack->Pop()->GetString();

-		int index = stack->Pop()->GetInt();

+		const char *strToFind = stack->pop()->GetString();

+		int index = stack->pop()->GetInt();

 

 		WideString str;

 		if (Game->_textEncoding == TEXT_UTF8)

@@ -235,7 +235,7 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 			toFind = StringUtil::AnsiToWide(strToFind);

 

 		int indexOf = StringUtil::IndexOf(str, toFind, index);

-		stack->PushInt(indexOf);

+		stack->pushInt(indexOf);

 

 		return S_OK;

 	}

@@ -244,14 +244,14 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 	// Split

 	//////////////////////////////////////////////////////////////////////////

 	else if (strcmp(name, "Split") == 0) {

-		stack->CorrectParams(1);

-		CScValue *Val = stack->Pop();

+		stack->correctParams(1);

+		CScValue *Val = stack->pop();

 		char Separators[MAX_PATH] = ",";

 		if (!Val->IsNULL()) strcpy(Separators, Val->GetString());

 

 		CSXArray *Array = new CSXArray(Game);

 		if (!Array) {

-			stack->PushNULL();

+			stack->pushNULL();

 			return S_OK;

 		}

 

@@ -308,7 +308,7 @@ HRESULT CSXString::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 			Val = NULL;

 		}

 

-		stack->PushNative(Array, false);

+		stack->pushNative(Array, false);

 		return S_OK;

 	}

 

diff --git a/engines/wintermute/Base/scriptables/ScEngine.cpp b/engines/wintermute/Base/scriptables/ScEngine.cpp
index 9c443df509..e840d0cd78 100644
--- a/engines/wintermute/Base/scriptables/ScEngine.cpp
+++ b/engines/wintermute/Base/scriptables/ScEngine.cpp
@@ -407,13 +407,13 @@ HRESULT CScEngine::Tick() {
 		case SCRIPT_WAITING_SCRIPT: {

 			if (!IsValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {

 				// fake return value

-				_scripts[i]->_stack->PushNULL();

+				_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]->_stack->push(_scripts[i]->_waitScript->_stack->pop());

 					_scripts[i]->Run();

 					_scripts[i]->_waitScript->finish();

 					_scripts[i]->_waitScript = NULL;

diff --git a/engines/wintermute/Base/scriptables/ScScript.cpp b/engines/wintermute/Base/scriptables/ScScript.cpp
index 6e43ac6e0d..61e1e91282 100644
--- a/engines/wintermute/Base/scriptables/ScScript.cpp
+++ b/engines/wintermute/Base/scriptables/ScScript.cpp
@@ -493,9 +493,9 @@ HRESULT CScScript::ExecuteInstruction() {
 			if (Game->GetDebugMgr()->_enabled)

 				Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCRIPT, this, NULL, _globals->GetProp(_symbols[dw]), _symbols[dw]);

 		} else {

-			_scopeStack->GetTop()->SetProp(_symbols[dw], _operand);

+			_scopeStack->getTop()->SetProp(_symbols[dw], _operand);

 			if (Game->GetDebugMgr()->_enabled)

-				Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCOPE, this, _scopeStack->GetTop(), _scopeStack->GetTop()->GetProp(_symbols[dw]), _symbols[dw]);

+				Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCOPE, this, _scopeStack->getTop(), _scopeStack->getTop()->GetProp(_symbols[dw]), _symbols[dw]);

 		}

 

 		break;

@@ -517,13 +517,13 @@ HRESULT CScScript::ExecuteInstruction() {
 

 	case II_RET:

 		if (_scopeStack->_sP >= 0 && _callStack->_sP >= 0) {

-			Game->GetDebugMgr()->OnScriptShutdownScope(this, _scopeStack->GetTop());

+			Game->GetDebugMgr()->OnScriptShutdownScope(this, _scopeStack->getTop());

 

-			_scopeStack->Pop();

-			_iP = (uint32)_callStack->Pop()->GetInt();

+			_scopeStack->pop();

+			_iP = (uint32)_callStack->pop()->GetInt();

 

 			if (_scopeStack->_sP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);

-			else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->GetTop());

+			else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->getTop());

 		} else {

 			if (_thread) {

 				_state = SCRIPT_THREAD_FINISHED;

@@ -544,7 +544,7 @@ HRESULT CScScript::ExecuteInstruction() {
 		dw = GetDWORD();

 

 		_operand->SetInt(_iP);

-		_callStack->Push(_operand);

+		_callStack->push(_operand);

 

 		_iP = dw;

 

@@ -553,11 +553,11 @@ HRESULT CScScript::ExecuteInstruction() {
 	case II_CALL_BY_EXP: {

 		// push var

 		// push string

-		str = _stack->Pop()->GetString();

+		str = _stack->pop()->GetString();

 		char *MethodName = new char[strlen(str) + 1];

 		strcpy(MethodName, str);

 

-		CScValue *var = _stack->Pop();

+		CScValue *var = _stack->pop();

 		if (var->_type == VAL_VARIABLE_REF) var = var->_valRef;

 

 		HRESULT res = E_FAIL;

@@ -574,18 +574,18 @@ HRESULT CScScript::ExecuteInstruction() {
 				if (!_unbreakable) {

 					_waitScript = var->GetNative()->invokeMethodThread(MethodName);

 					if (!_waitScript) {

-						_stack->CorrectParams(0);

+						_stack->correctParams(0);

 						RuntimeError("Error invoking method '%s'.", MethodName);

-						_stack->PushNULL();

+						_stack->pushNULL();

 					} else {

 						_state = SCRIPT_WAITING_SCRIPT;

 						_waitScript->CopyParameters(_stack);

 					}

 				} else {

 					// can call methods in unbreakable mode

-					_stack->CorrectParams(0);

+					_stack->correctParams(0);

 					RuntimeError("Cannot call method '%s'. Ignored.", MethodName);

-					_stack->PushNULL();

+					_stack->pushNULL();

 				}

 				delete [] MethodName;

 				break;

@@ -616,9 +616,9 @@ HRESULT CScScript::ExecuteInstruction() {
 				if (var->_type == VAL_NATIVE && !TriedNative) res = var->_valNative->scCallMethod(this, _stack, _thisStack, MethodName);

 

 				if (FAILED(res)) {

-					_stack->CorrectParams(0);

+					_stack->correctParams(0);

 					RuntimeError("Call to undefined method '%s'. Ignored.", MethodName);

-					_stack->PushNULL();

+					_stack->pushNULL();

 				}

 			}

 		}

@@ -638,40 +638,40 @@ HRESULT CScScript::ExecuteInstruction() {
 	}

 	case II_SCOPE:

 		_operand->SetNULL();

-		_scopeStack->Push(_operand);

+		_scopeStack->push(_operand);

 

 		if (_scopeStack->_sP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);

-		else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->GetTop());

+		else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->getTop());

 

 		break;

 

 	case II_CORRECT_STACK:

 		dw = GetDWORD(); // params expected

-		_stack->CorrectParams(dw);

+		_stack->correctParams(dw);

 		break;

 

 	case II_CREATE_OBJECT:

 		_operand->SetObject();

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_POP_EMPTY:

-		_stack->Pop();

+		_stack->pop();

 		break;

 

 	case II_PUSH_VAR: {

 		CScValue *var = GetVar(_symbols[GetDWORD()]);

 		if (false && /*var->_type==VAL_OBJECT ||*/ var->_type == VAL_NATIVE) {

 			_operand->SetReference(var);

-			_stack->Push(_operand);

-		} else _stack->Push(var);

+			_stack->push(_operand);

+		} else _stack->push(var);

 		break;

 	}

 

 	case II_PUSH_VAR_REF: {

 		CScValue *var = GetVar(_symbols[GetDWORD()]);

 		_operand->SetReference(var);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 	}

 

@@ -679,7 +679,7 @@ HRESULT CScScript::ExecuteInstruction() {
 		char *VarName = _symbols[GetDWORD()];

 		CScValue *var = GetVar(VarName);

 		if (var) {

-			CScValue *val = _stack->Pop();

+			CScValue *val = _stack->pop();

 			if (!val) {

 				RuntimeError("Script stack corruption detected. Please report this script at WME bug reports forum.");

 				var->SetNULL();

@@ -699,58 +699,58 @@ HRESULT CScScript::ExecuteInstruction() {
 	}

 

 	case II_PUSH_VAR_THIS:

-		_stack->Push(_thisStack->GetTop());

+		_stack->push(_thisStack->getTop());

 		break;

 

 	case II_PUSH_INT:

-		_stack->PushInt((int)GetDWORD());

+		_stack->pushInt((int)GetDWORD());

 		break;

 

 	case II_PUSH_FLOAT:

-		_stack->PushFloat(GetFloat());

+		_stack->pushFloat(GetFloat());

 		break;

 

 

 	case II_PUSH_BOOL:

-		_stack->PushBool(GetDWORD() != 0);

+		_stack->pushBool(GetDWORD() != 0);

 

 		break;

 

 	case II_PUSH_STRING:

-		_stack->PushString(GetString());

+		_stack->pushString(GetString());

 		break;

 

 	case II_PUSH_NULL:

-		_stack->PushNULL();

+		_stack->pushNULL();

 		break;

 

 	case II_PUSH_THIS_FROM_STACK:

-		_operand->SetReference(_stack->GetTop());

-		_thisStack->Push(_operand);

+		_operand->SetReference(_stack->getTop());

+		_thisStack->push(_operand);

 		break;

 

 	case II_PUSH_THIS:

 		_operand->SetReference(GetVar(_symbols[GetDWORD()]));

-		_thisStack->Push(_operand);

+		_thisStack->push(_operand);

 		break;

 

 	case II_POP_THIS:

-		_thisStack->Pop();

+		_thisStack->pop();

 		break;

 

 	case II_PUSH_BY_EXP: {

-		str = _stack->Pop()->GetString();

-		CScValue *val = _stack->Pop()->GetProp(str);

-		if (val) _stack->Push(val);

-		else _stack->PushNULL();

+		str = _stack->pop()->GetString();

+		CScValue *val = _stack->pop()->GetProp(str);

+		if (val) _stack->push(val);

+		else _stack->pushNULL();

 

 		break;

 	}

 

 	case II_POP_BY_EXP: {

-		str = _stack->Pop()->GetString();

-		CScValue *var = _stack->Pop();

-		CScValue *val = _stack->Pop();

+		str = _stack->pop()->GetString();

+		CScValue *var = _stack->pop();

+		CScValue *val = _stack->pop();

 

 		if (val == NULL) {

 			RuntimeError("Script stack corruption detected. Please report this script at WME bug reports forum.");

@@ -764,11 +764,11 @@ HRESULT CScScript::ExecuteInstruction() {
 	}

 

 	case II_PUSH_REG1:

-		_stack->Push(_reg1);

+		_stack->push(_reg1);

 		break;

 

 	case II_POP_REG1:

-		_reg1->Copy(_stack->Pop());

+		_reg1->Copy(_stack->pop());

 		break;

 

 	case II_JMP:

@@ -777,8 +777,8 @@ HRESULT CScScript::ExecuteInstruction() {
 

 	case II_JMP_FALSE: {

 		dw = GetDWORD();

-		//if(!_stack->Pop()->GetBool()) _iP = dw;

-		CScValue *Val = _stack->Pop();

+		//if(!_stack->pop()->GetBool()) _iP = dw;

+		CScValue *Val = _stack->pop();

 		if (!Val) {

 			RuntimeError("Script corruption detected. Did you use '=' instead of '==' for comparison?");

 		} else {

@@ -788,8 +788,8 @@ HRESULT CScScript::ExecuteInstruction() {
 	}

 

 	case II_ADD:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();

 		else if (op1->GetType() == VAL_STRING || op2->GetType() == VAL_STRING) {

@@ -802,98 +802,98 @@ HRESULT CScScript::ExecuteInstruction() {
 			_operand->SetInt(op1->GetInt() + op2->GetInt());

 		else _operand->SetFloat(op1->GetFloat() + op2->GetFloat());

 

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_SUB:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();

 		else if (op1->GetType() == VAL_INT && op2->GetType() == VAL_INT)

 			_operand->SetInt(op1->GetInt() - op2->GetInt());

 		else _operand->SetFloat(op1->GetFloat() - op2->GetFloat());

 

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_MUL:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();

 		else if (op1->GetType() == VAL_INT && op2->GetType() == VAL_INT)

 			_operand->SetInt(op1->GetInt() * op2->GetInt());

 		else _operand->SetFloat(op1->GetFloat() * op2->GetFloat());

 

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_DIV:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		if (op2->GetFloat() == 0.0f) RuntimeError("Division by zero.");

 

 		if (op1->IsNULL() || op2->IsNULL() || op2->GetFloat() == 0.0f) _operand->SetNULL();

 		else _operand->SetFloat(op1->GetFloat() / op2->GetFloat());

 

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_MODULO:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		if (op2->GetInt() == 0) RuntimeError("Division by zero.");

 

 		if (op1->IsNULL() || op2->IsNULL() || op2->GetInt() == 0) _operand->SetNULL();

 		else _operand->SetInt(op1->GetInt() % op2->GetInt());

 

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_NOT:

-		op1 = _stack->Pop();

+		op1 = _stack->pop();

 		//if(op1->IsNULL()) _operand->SetNULL();

 		if (op1->IsNULL()) _operand->SetBool(true);

 		else _operand->SetBool(!op1->GetBool());

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_AND:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 		if (op1 == NULL || op2 == NULL) {

 			RuntimeError("Script corruption detected. Did you use '=' instead of '==' for comparison?");

 			_operand->SetBool(false);

 		} else {

 			_operand->SetBool(op1->GetBool() && op2->GetBool());

 		}

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_OR:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 		if (op1 == NULL || op2 == NULL) {

 			RuntimeError("Script corruption detected. Did you use '=' instead of '==' for comparison?");

 			_operand->SetBool(false);

 		} else {

 			_operand->SetBool(op1->GetBool() || op2->GetBool());

 		}

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_EQ:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) _operand->SetBool(false);

@@ -912,12 +912,12 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) == 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_NE:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) _operand->SetBool(true);

@@ -936,12 +936,12 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) != 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_L:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){

@@ -951,12 +951,12 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) < 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_G:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){

@@ -966,12 +966,12 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) > 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_LE:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){

@@ -981,12 +981,12 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) <= 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_GE:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		/*

 		if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){

@@ -996,26 +996,26 @@ HRESULT CScScript::ExecuteInstruction() {
 		*/

 

 		_operand->SetBool(CScValue::Compare(op1, op2) >= 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_CMP_STRICT_EQ:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		//_operand->SetBool(op1->GetType()==op2->GetType() && op1->GetFloat()==op2->GetFloat());

 		_operand->SetBool(CScValue::CompareStrict(op1, op2) == 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 

 		break;

 

 	case II_CMP_STRICT_NE:

-		op2 = _stack->Pop();

-		op1 = _stack->Pop();

+		op2 = _stack->pop();

+		op1 = _stack->pop();

 

 		//_operand->SetBool(op1->GetType()!=op2->GetType() || op1->GetFloat()!=op2->GetFloat());

 		_operand->SetBool(CScValue::CompareStrict(op1, op2) != 0);

-		_stack->Push(_operand);

+		_stack->push(_operand);

 		break;

 

 	case II_DBG_LINE: {

@@ -1077,7 +1077,7 @@ CScValue *CScScript::GetVar(char *name) {
 

 	// scope locals

 	if (_scopeStack->_sP >= 0) {

-		if (_scopeStack->GetTop()->PropExists(name)) ret = _scopeStack->GetTop()->GetProp(name);

+		if (_scopeStack->getTop()->PropExists(name)) ret = _scopeStack->getTop()->GetProp(name);

 	}

 

 	// script globals

@@ -1094,10 +1094,10 @@ CScValue *CScScript::GetVar(char *name) {
 		//RuntimeError("Variable '%s' is inaccessible in the current block. Consider changing the script.", name);

 		Game->LOG(0, "Warning: variable '%s' is inaccessible in the current block. Consider changing the script (script:%s, line:%d)", name, _filename, _currentLine);

 		CScValue *Val = new CScValue(Game);

-		CScValue *Scope = _scopeStack->GetTop();

+		CScValue *Scope = _scopeStack->getTop();

 		if (Scope) {

 			Scope->SetProp(name, Val);

-			ret = _scopeStack->GetTop()->GetProp(name);

+			ret = _scopeStack->getTop()->GetProp(name);

 		} else {

 			_globals->SetProp(name, Val);

 			ret = _globals->GetProp(name);

@@ -1331,8 +1331,8 @@ HRESULT CScScript::ExternalCall(CScStack *stack, CScStack *thisStack, CScScript:
 #ifndef __WIN32__

 

 	Game->LOG(0, "External functions are not supported on this platform.");

-	stack->CorrectParams(0);

-	stack->PushNULL();

+	stack->correctParams(0);

+	stack->pushNULL();

 	return E_FAIL;

 

 #else

@@ -1345,11 +1345,11 @@ HRESULT CScScript::ExternalCall(CScStack *stack, CScStack *thisStack, CScScript:
 		if (pFunc) {

 			int i;

 			Success = true;

-			stack->CorrectParams(Function->nu_params);

+			stack->correctParams(Function->nu_params);

 			CBDynBuffer *Buffer = new CBDynBuffer(Game, 20 * sizeof(uint32));

 

 			for (i = 0; i < Function->nu_params; i++) {

-				CScValue *Val = stack->Pop();

+				CScValue *Val = stack->pop();

 				switch (Function->params[i]) {

 				case TYPE_BOOL:

 					Buffer->PutDWORD((uint32)Val->GetBool());

@@ -1399,34 +1399,34 @@ HRESULT CScScript::ExternalCall(CScStack *stack, CScStack *thisStack, CScScript:
 			// return

 			switch (Function->returns) {

 			case TYPE_BOOL:

-				stack->PushBool((byte)ret != 0);

+				stack->pushBool((byte)ret != 0);

 				break;

 			case TYPE_LONG:

-				stack->PushInt(ret);

+				stack->pushInt(ret);

 				break;

 			case TYPE_BYTE:

-				stack->PushInt((byte)ret);

+				stack->pushInt((byte)ret);

 				break;

 				break;

 			case TYPE_STRING:

-				stack->PushString((char *)ret);

+				stack->pushString((char *)ret);

 				break;

 			case TYPE_MEMBUFFER: {

 				CSXMemBuffer *Buf = new CSXMemBuffer(Game, (void *)ret);

-				stack->PushNative(Buf, false);

+				stack->pushNative(Buf, false);

 			}

 			break;

 			case TYPE_FLOAT: {

 				uint32 dw = GetST0();

-				stack->PushFloat(*((float *)&dw));

+				stack->pushFloat(*((float *)&dw));

 				break;

 			}

 			case TYPE_DOUBLE:

-				stack->PushFloat(GetST0Double());

+				stack->pushFloat(GetST0Double());

 				break;

 

 			default:

-				stack->PushNULL();

+				stack->pushNULL();

 			}

 

 			if (StackCorrupted) RuntimeError("Warning: Stack corrupted after calling '%s' in '%s'\n         Check parameters and/or calling convention.", Function->name, Function->dll_name);

@@ -1434,8 +1434,8 @@ HRESULT CScScript::ExternalCall(CScStack *stack, CScStack *thisStack, CScScript:
 	} else RuntimeError("Error loading DLL '%s'", Function->dll_name);

 

 	if (!Success) {

-		stack->CorrectParams(0);

-		stack->PushNULL();

+		stack->correctParams(0);

+		stack->pushNULL();

 	}

 

 	if (hDll) FreeLibrary(hDll);

@@ -1527,13 +1527,13 @@ double CScScript::GetST0Double(void) {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CScScript::CopyParameters(CScStack *stack) {

 	int i;

-	int NumParams = stack->Pop()->GetInt();

+	int NumParams = stack->pop()->GetInt();

 	for (i = NumParams - 1; i >= 0; i--) {

-		_stack->Push(stack->GetAt(i));

+		_stack->push(stack->getAt(i));

 	}

-	_stack->PushInt(NumParams);

+	_stack->pushInt(NumParams);

 

-	for (i = 0; i < NumParams; i++) stack->Pop();

+	for (i = 0; i < NumParams; i++) stack->pop();

 

 	return S_OK;

 }

diff --git a/engines/wintermute/Base/scriptables/ScStack.cpp b/engines/wintermute/Base/scriptables/ScStack.cpp
index f10aa7085b..dc953ed8d0 100644
--- a/engines/wintermute/Base/scriptables/ScStack.cpp
+++ b/engines/wintermute/Base/scriptables/ScStack.cpp
@@ -55,7 +55,7 @@ CScStack::~CScStack() {
 

 

 //////////////////////////////////////////////////////////////////////////

-CScValue *CScStack::Pop() {

+CScValue *CScStack::pop() {

 	if (_sP < 0) {

 		Game->LOG(0, "Fatal: Stack underflow");

 		return NULL;

@@ -66,7 +66,7 @@ CScValue *CScStack::Pop() {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::Push(CScValue *val) {

+void CScStack::push(CScValue *val) {

 	_sP++;

 

 	if (_sP < _values.GetSize()) {

@@ -81,7 +81,7 @@ void CScStack::Push(CScValue *val) {
 

 

 //////////////////////////////////////////////////////////////////////////

-CScValue *CScStack::GetPushValue() {

+CScValue *CScStack::getPushValue() {

 	_sP++;

 

 	if (_sP >= _values.GetSize()) {

@@ -95,14 +95,14 @@ CScValue *CScStack::GetPushValue() {
 

 

 //////////////////////////////////////////////////////////////////////////

-CScValue *CScStack::GetTop() {

+CScValue *CScStack::getTop() {

 	if (_sP < 0 || _sP >= _values.GetSize()) return NULL;

 	else return _values[_sP];

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-CScValue *CScStack::GetAt(int index) {

+CScValue *CScStack::getAt(int index) {

 	index = _sP - index;

 	if (index < 0 || index >= _values.GetSize()) return NULL;

 	else return _values[index];

@@ -110,8 +110,8 @@ CScValue *CScStack::GetAt(int index) {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::CorrectParams(uint32 expected_params) {

-	int nu_params = Pop()->GetInt();

+void CScStack::correctParams(uint32 expected_params) {

+	int nu_params = pop()->GetInt();

 

 	if (expected_params < nu_params) { // too many params

 		while (expected_params < nu_params) {

@@ -140,67 +140,67 @@ void CScStack::CorrectParams(uint32 expected_params) {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushNULL() {

+void CScStack::pushNULL() {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetNULL();

 	Push(val);

 	delete val;

 	*/

-	GetPushValue()->SetNULL();

+	getPushValue()->SetNULL();

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushInt(int val) {

+void CScStack::pushInt(int val) {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetInt(Val);

 	Push(val);

 	delete val;

 	*/

-	GetPushValue()->SetInt(val);

+	getPushValue()->SetInt(val);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushFloat(double val) {

+void CScStack::pushFloat(double val) {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetFloat(Val);

 	Push(val);

 	delete val;

 	*/

-	GetPushValue()->SetFloat(val);

+	getPushValue()->SetFloat(val);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushBool(bool val) {

+void CScStack::pushBool(bool val) {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetBool(Val);

 	Push(val);

 	delete val;

 	*/

-	GetPushValue()->SetBool(val);

+	getPushValue()->SetBool(val);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushString(const char *val) {

+void CScStack::pushString(const char *val) {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetString(Val);

 	Push(val);

 	delete val;

 	*/

-	GetPushValue()->SetString(val);

+	getPushValue()->SetString(val);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-void CScStack::PushNative(CBScriptable *val, bool persistent) {

+void CScStack::pushNative(CBScriptable *val, bool persistent) {

 	/*

 	CScValue* val = new CScValue(Game);

 	val->SetNative(Val, Persistent);

@@ -208,7 +208,7 @@ void CScStack::PushNative(CBScriptable *val, bool persistent) {
 	delete val;

 	*/

 

-	GetPushValue()->SetNative(val, persistent);

+	getPushValue()->SetNative(val, persistent);

 }

 

 

diff --git a/engines/wintermute/Base/scriptables/ScStack.h b/engines/wintermute/Base/scriptables/ScStack.h
index 3e7f557cdd..b2d5f15c1c 100644
--- a/engines/wintermute/Base/scriptables/ScStack.h
+++ b/engines/wintermute/Base/scriptables/ScStack.h
@@ -41,19 +41,19 @@ class CBScriptable;
 

 class CScStack : public CBBase {

 public:

-	CScValue *GetAt(int Index);

-	CScValue *GetPushValue();

+	CScValue *getAt(int Index);

+	CScValue *getPushValue();

 	DECLARE_PERSISTENT(CScStack, CBBase)

-	void PushNative(CBScriptable *Val, bool Persistent);

-	void PushString(const char *Val);

-	void PushBool(bool Val);

-	void PushInt(int Val);

-	void PushFloat(double Val);

-	void PushNULL();

-	void CorrectParams(uint32 expected_params);

-	CScValue *GetTop();

-	void Push(CScValue *Val);

-	CScValue *Pop();

+	void pushNative(CBScriptable *Val, bool Persistent);

+	void pushString(const char *Val);

+	void pushBool(bool Val);

+	void pushInt(int Val);

+	void pushFloat(double Val);

+	void pushNULL();

+	void correctParams(uint32 expected_params);

+	CScValue *getTop();

+	void push(CScValue *Val);

+	CScValue *pop();

 	CScStack(CBGame *inGame);

 	virtual ~CScStack();

 	CBArray<CScValue *, CScValue *> _values;

diff --git a/engines/wintermute/Base/scriptables/SxObject.cpp b/engines/wintermute/Base/scriptables/SxObject.cpp
index ff51134321..b4fd782f76 100644
--- a/engines/wintermute/Base/scriptables/SxObject.cpp
+++ b/engines/wintermute/Base/scriptables/SxObject.cpp
@@ -44,9 +44,9 @@ CBScriptable *makeSXObject(CBGame *inGame, CScStack *stack) {
 

 //////////////////////////////////////////////////////////////////////////

 CSXObject::CSXObject(CBGame *inGame, CScStack *stack): CBObject(inGame) {

-	int NumParams = stack->Pop()->GetInt(0);

+	int NumParams = stack->pop()->GetInt(0);

 	for (int i = 0; i < NumParams; i++) {

-		addScript(stack->Pop()->GetString());

+		addScript(stack->pop()->GetString());

 	}

 }